~NAXC~

File Content: `PresentationController.php`

<?php

namespace App\Http\Controllers;

use App\Models\Abstracts;
use App\Models\File;
use Illuminate\Support\Facades\Log;
use Illuminate\Support\Facades\DB;
use App\Models\Presentation;
use App\Models\Session;
use App\Models\PresentationComment;
use App\Models\PresentationReview;
use App\Models\Presenter;
use App\Models\Slot;
use App\Repositories\PresentationRepository;
use Exception;
use Illuminate\Http\Request;
use Illuminate\Support\Facades\Storage;
use App\Jobs\SendPresentationEditRequestMail;
use ZipArchive;
use App\Repositories\UserRepository;
use App\Models\User;
use Illuminate\Support\Facades\URL;
use Illuminate\Support\Str;

class PresentationController extends Controller
{
    protected PresentationRepository $repository;

    public function __construct(PresentationRepository $presentationRepository)
    {
        $this->repository = $presentationRepository;

        $this->middleware('event.user:event_admin|event_submitter|event_reviewer|event_co_chair');
    }

    /**
     * @OA\Get(
     *  path="/api/presentation/list",
     *  summary="Get the list of presentations in an event",
     *  tags={"Presentation"},
     *  @OA\Parameter(name="role",
     *    in="header",
     *    required=true,
     *    @OA\Schema(type="string")
     *  ),
     *     @OA\Parameter(name="slug-name",
     *    in="header",
     *    required=true,
     *    @OA\Schema(type="string")
     *  ),
     *      @OA\Parameter(name="paging",
     *    in="query",
     *    required=false,
     *    description="No. of records in a page. You can use 'All' to get all result",
     *    @OA\Schema(type="string")
     *  ),
     *     @OA\Parameter(name="page",
     *    in="query",
     *    required=false,
     *    @OA\Schema(type="integer")
     *  ),
     *     @OA\Parameter(name="search",
     *    in="query",
     *    required=false,
     *    description="Search by any keyword",
     *    @OA\Schema(type="string")
     *  ),
     *     @OA\Parameter(name="sort",
     *    in="query",
     *    required=false,
     *    description="Sort the list by columns. eg. {""id"":""asc""}. Multisort available eg. {""id"":""asc"",""submitter"":""asc""}. Available column names id,submitter,presenters,submission_status.",
     *    @OA\Schema(type="json")
     *  ),
     *     @OA\Parameter(name="filter",
     *    in="query",
     *    required=false,
     *    description="Filter for presentation list. Only one filter is available. Assigned true or false. eg. {""assigned"":false}",
     *    @OA\Schema(type="json")
     *  ),
     *  @OA\Response(response="200",
     *    description="List of presentations",
     *  )
     * )
     */
    public function list(Request $request)
    {
        try {

            $data = $this->repository->listing($request, true);

            $paging = $request->get('paging', '10');
            $idsOnly = $request->get('ids_only', false);
            $idsOnly = $idsOnly == 'true';
            $total = $data->count();
            // auth user created presentation count without abstracts
            $presentationAuthUserCreatedCount = Presentation::whereUserId(authUser()->id)->whereEventId(
                $request->get('event')->id
            )->where('type', '=', 'presentation')->count();


            if ($idsOnly) {
                $data = $data->pluck('id')->toArray();
            }

            return response([
                'status' => true,
                'presentations' => $paging == 'All' && !$idsOnly ? ['data' => $data, 'total' => $total, 'auc' => $presentationAuthUserCreatedCount] : $data
            ]);
        }
        catch (Exception $exception) {
            return $this->handleException($exception, __FUNCTION__, __CLASS__);
        }
    }

    // Downloading presentation files

    public function download(Request $request)
    {
        try {
            // role
            $role = $request->get('role');
            // event admin
            if ($role != 'event_admin')
                return response([
                    'status' => false,
                    'message' => 'Access denied'
                ]);

            // all presentation ids
            $presentationIds = $request['presentation_ids'];

            if (!$presentationIds)
                return response([
                    'status' => false,
                    'message' => 'Presentation not found'
                ]);

            $presentations = Presentation::findMany($presentationIds);

            if (!$presentations) {
                return response([
                    'status' => false,
                    'message' => 'No files'
                ]);
            }
            // add files to zip
            return $this->repository->addingToZip($presentations, $request);
        }
        catch (Exception $exception) {
            return $this->handleException($exception, __FUNCTION__, __CLASS__);
        }
    }
    public function view(Request $request, $id)
    {
        try {
            $event = $request->get('event');
            $presentation = $this->repository->fetchPresentation($id, $event->id);
            if (!$presentation)
                validationErrorResponse(['Invalid presentation id']);

            $role = $request->get('role');
            if ($role != 'event_admin' && $presentation->event_id != $event->id)
                return response([
                    'status' => false,
                    'message' => 'Access denied'
                ]);

            if ($role == 'event_submitter') {
                $presenters = $presentation->presenters->pluck('id')->toArray();
                if ($presentation->user_id != authUser()->id && !in_array(authUser()->id, $presenters))
                    return response([
                        'status' => false,
                        'message' => 'Access denied'
                    ]);
            }

            if ($role == 'event_reviewer') {
                $reviewer = $presentation->reviewers(authUser()->id)->first();
                if (!$reviewer) {
                    return response([
                        'status' => false,
                        'message' => 'Access denied'
                    ]);
                }
            }

            // Add contact_restricted flag for presenters
            $authEventUser = $request->get('event_user');
            if ($presentation->presenters) {
                $presentation->presenters->each(function ($user) use ($authEventUser) {
                    $user->contact_restricted = shouldRestrictContact($user, $authEventUser);
                });
            }

            return response([
                'status' => true,
                'presentation' => $presentation
            ]);
        }
        catch (Exception $exception) {
            return $this->handleException($exception, __FUNCTION__, __CLASS__);
        }
    }

    // getting all submitter present in an event

    public function fetchFilterDetails(Request $request)
    {
        try {
            // role
            $role = $request->get('role');
            if ($role != 'event_admin')
                return response([
                    'status' => false,
                    'message' => 'Access denied'
                ]);
            // event
            $event = $request->get('event');
            // submitters
            $submitters = $event->users('event_submitter')->select('email', 'first_name', 'last_name')->get()->toArray();

            // fetching Assigned Reviewers data
            $reviewers = PresentationReview::join('users', 'presentation_reviews.reviewer_id', '=', 'users.id')
                ->select(DB::raw("CONCAT(users.first_name, ' ', users.last_name) as name"), "email")
                ->where('presentation_reviews.event_id', $event->id)->groupBy('users.id')->distinct()
                ->get();


            // fetching Presenters data
            $presenters = Presenter::join('users', 'presenters.user_id', '=', 'users.id')
                ->select(DB::raw("CONCAT(users.first_name, ' ', users.last_name) as name"), "email")
                ->where('presenters.event_id', $event->id)->groupBy('users.id')->distinct()
                ->get();


            // fetching Abstract Id
            $abstractIds = Presentation::whereNotNull('abstract_id')
                ->where('event_id', '=', $event->id)->pluck('abstract_id')->unique()->toArray();
            $abstractIds = array_values($abstractIds);

            // companies
            $companies = User::all()->whereNotNull('company')->pluck('company')->unique()->toArray();
            $companies = array_values($companies);

            // sessions
            $sessions = Session::all()->where('event_id', '=', $event->id)->pluck('title')->unique()->toArray();
            $sessions = array_values($sessions);

            // slots
            $slots = Slot::all()->where('event_id', '=', $event->id)->pluck('title')->unique()->toArray();
            $slots = array_values($slots);

            return response([
                'status' => true,
                'submitters' => $submitters,
                'reviewers' => $reviewers,
                'presenters' => $presenters,
                'abstractIds' => $abstractIds,
                'companies' => $companies,
                'sessions' => $sessions,
                'slots' => $slots
            ]);
        } catch (Exception $exception) {
            return $this->handleException($exception, __FUNCTION__, __CLASS__);
        }
    }

    public function createOrUpdate(Request $request)
    {
        try {
            $eventUser = $request->get('event_user');
            $role = $request->get('role');
            if (!$eventUser->hasPermissionTo('create presentation', 'web') && !$eventUser->hasPermissionTo('edit presentation', 'web'))
                return response([
                    'status' => false,
                    'message' => "Access denied"
                ]);

            $presentation = $this->repository->createOrUpdate($request);
            $presentation->load('presenters');

            activity('abstract.createOrUpdate')
                ->performedOn($presentation)
                ->causedBy(authUser())
                ->log(($role == 'event_admin' ? 'Admin :' : 'Submitter') . 'submitted presentation');

            return response([
                'status' => true,
                'presentation' => $presentation
            ]);
        }
        catch (Exception $exception) {
            return $this->handleException($exception, __FUNCTION__, __CLASS__);
        }
    }

    public function writtenPaper(Request $request)
    {
        try {
            $role = $request->get('role');
            $eventUser = $request->get('event_user');
            
            // Allow admins to edit written papers
            if ($role === 'event_admin') {
                if (!$eventUser->hasRole('event_admin'))
                    return response([
                        'status' => false,
                        'message' => "Access denied"
                    ]);
            } else {
                if (!$eventUser->hasPermissionTo('create presentation') && !$eventUser->hasPermissionTo('edit presentation'))
                    return response([
                        'status' => false,
                        'message' => "Access denied"
                    ]);
            }

            $presentation = $this->repository->writtenPaper($request);

            return response([
                'status' => true,
                'presentation' => $presentation
            ]);
        }
        catch (Exception $exception) {
            return $this->handleException($exception, __FUNCTION__, __CLASS__);
        }
    }

    public function delete(Request $request, $id)
    {
        try {
            $presentation = Presentation::find($id);
            if (!$presentation)
                return response([
                    'status' => false,
                    'message' => 'Presentation not found'
                ]);

            $role = $request->get('role');
            if ($role != 'event_admin')
                return response([
                    'status' => false,
                    'message' => 'Access denied'
                ]);

            $eventUser = $request->get('event_user');
            if (!$eventUser->hasRole($role))
                return response([
                    'status' => false,
                    'message' => 'Access denied'
                ]);

            $delete = $this->repository->deletePresentation($presentation);

            if ($delete) {
                activity('abstract.createOrUpdate')
                    ->performedOn($presentation)
                    ->causedBy(authUser())
                    ->log("Admin deleted abstract");

                return response([
                    'status' => true,
                    'message' => 'Successfully deleted presentation'
                ]);
            }

            return response([
                'status' => false,
                'message' => 'Cannot delete the presentation. The presentation is added to a slot'
            ]);
        }
        catch (Exception $exception) {
            return $this->handleException($exception, __FUNCTION__, __CLASS__);
        }
    }

    /**
     * @throws Exception
     */
    public function listComments(Request $request, $presentationId)
    {
        try {
            $request->merge(['presentation_id' => $presentationId]);

            $data = $this->repository->getCommentRepository()->listing($request, true);

            $paging = $request->get('paging', '10');

            return response([
                'status' => true,
                'presentation_comments' => $paging == 'All' ? ['data' => $data] : $data
            ]);
        }
        catch (Exception $exception) {
            return $this->handleException($exception, __FUNCTION__, __CLASS__);
        }
    }

    public function createOrUpdateComment(Request $request, $presentationId)
    {
        try {
            $role = $request->get('role');
            $request->merge(['presentation_id' => (int)$presentationId]);

            $presentationComment = $this->repository->getCommentRepository()->createOrUpdate($request);
            $presentationComment->load('user');

            activity('presentation_comment.createOrUpdate')
                ->performedOn($presentationComment)
                ->causedBy(authUser())
                ->log(($role) . 'created comment');

            return response([
                'status' => true,
                'presentation_comment' => $presentationComment
            ]);
        }
        catch (Exception $exception) {
            return $this->handleException($exception, __FUNCTION__, __CLASS__);
        }
    }


    /**
     * @OA\Get(
     *  path="/api/presentation/{id}/file/{fileId}",
     *  summary="Get the presentation file",
     *  tags={"Presentation"},
     *     @OA\Parameter(name="role",
     *    in="header",
     *    required=true,
     *    @OA\Schema(type="string")
     *  ),
     *     @OA\Parameter(name="slug-name",
     *    in="header",
     *    required=true,
     *    @OA\Schema(type="string")
     *  ),
     *      @OA\Parameter(name="id",
     *    in="path",
     *    required=true,
     *    description="Presentation Id",
     *    @OA\Schema(type="integer")
     *  ),
     *     @OA\Parameter(name="fileId",
     *    in="path",
     *    required=true,
     *    description="File Id",
     *    @OA\Schema(type="integer")
     *  ),
     *  @OA\Response(response="200",
     *    description="Presentation File",
     *  )
     * )
     */
    public function downloadFile(Request $request, $id, $fileId)
    {
        try {
            $file = File::whereId($fileId)
                ->whereModelId($id)
                ->whereModel(Presentation::class)
                ->first();
            if (!$file)
                return response([
                    'status' => false,
                    'message' => "File not found"
                ]);

            $filePath = $file->filepath . $file->save_name;

            return Storage::download($filePath, $file->filename);
        }
        catch (Exception $exception) {
            return $this->handleException($exception, __FUNCTION__, __CLASS__);
        }
    }

    public function downloadCommentFIle(Request $request, $id, $commentId, $fileId)
    {
        try {
            $file = File::whereId($fileId)
                ->whereModelId($commentId)
                ->whereModel(PresentationComment::class)
                ->first();
            if (!$file)
                return response([
                    'status' => false,
                    'message' => "File not found"
                ]);

            $filePath = $file->filepath . $file->save_name;
            return Storage::download($filePath, $file->filename);
        }
        catch (Exception $exception) {
            return $this->handleException($exception, __FUNCTION__, __CLASS__);
        }
    }

    public function assignReviewer(Request $request, $id)
    {
        try {
            $presentation = Presentation::find($id);
            if (!$presentation)
                return response([
                    'status' => false,
                    'message' => 'Presentation not found'
                ]);

            $role = $request->get('role');
            $event = $request->get('event');
            $user = authUser();
            $eventUser = getEventUser($event->id, $user->id);
            $eventRoles = $eventUser->roles->pluck('name')->toArray();
            if (!in_array($role, $eventRoles))
                return response([
                    'status' => false,
                    'message' => 'Access denied'
                ]);

            $reviewerId = $request->get('reviewer_id');

            $review = $this->repository->assignReviewer($presentation, $reviewerId);
            $review->load('reviewer');

            return response([
                'status' => true,
                'review' => $review
            ]);
        }
        catch (Exception $exception) {
            return $this->handleException($exception, __FUNCTION__, __CLASS__);
        }
    }

    public function removeReviewer(Request $request, $id)
    {
        $presentation = Presentation::find($id);
        if (!$presentation)
            return response([
                'status' => false,
                'message' => 'Presentation not found'
            ]);

        $role = $request->get('role');
        $event = $request->get('event');
        $user = authUser();
        $eventUser = getEventUser($event->id, $user->id);
        $eventRoles = $eventUser->roles->pluck('name')->toArray();
        if (!in_array($role, $eventRoles))
            return response([
                'status' => false,
                'message' => 'Access denied'
            ]);

        $reviewerId = $request->get('reviewer_id');
        $this->repository->removeReviewer($presentation, $reviewerId);

        return response([
            'status' => true,
            'message' => 'Successfully removed reviewer'
        ]);
    }



    // remove presenter from presentation
    public function removePresenter(Request $request, $id)
    {
        $presentation = Presentation::find($id);
        if (!$presentation)
            return response([
                'status' => false,
                'message' => 'Presentation not found'
            ]);

        $role = $request->get('role');
        $event = $request->get('event');
        $user = authUser();
        $eventUser = getEventUser($event->id, $user->id);
        $eventRoles = $eventUser->roles->pluck('name')->toArray();
        if (!in_array($role, $eventRoles))
            return response([
                'status' => false,
                'message' => 'Access denied'
            ]);

        $presenterId = $request->get('presenter_id');
        $this->repository->removePresenter($presentation, $presenterId);

        return response([
            'status' => true,
            'message' => 'Successfully removed presenter'
        ]);
    }


    /**
     * @throws Exception
     */
    public function editRequest(Request $request, $id)
    {
        try {
            $presentation = Presentation::find($id);
            if (!$presentation)
                return response([
                    'status' => false,
                    'message' => 'Presentation not found'
                ]);

            $role = $request->get('role');
            $event = $request->get('event');
            $user = authUser();
            $eventUser = getEventUser($event->id, $user->id);
            $eventRoles = $eventUser->roles->pluck('name')->toArray();
            if (!in_array($role, $eventRoles))
                return response([
                    'status' => false,
                    'message' => 'Access denied'
                ]);

            $presentation->edit_request = true;
            $presentation->save();

            //sending mail to admins
            $this->dispatch(new SendPresentationEditRequestMail($presentation));

            return response([
                'status' => true,
                'message' => 'Edit requested successfully'
            ]);
        }
        catch (Exception $exception) {
            return $this->handleException($exception, __FUNCTION__, __CLASS__);
        }
    }

    public function handleWrittenPaperEditRequest(Request $request, $id)
    {
        try {
            $presentation = Presentation::find($id);
            if (!$presentation)
                return response([
                    'status' => false,
                    'message' => 'Presentation not found'
                ]);

            $role = $request->get('role');
            if ($role != 'event_admin' && $role != 'event_reviewer')
                return response([
                    'status' => false,
                    'message' => 'Access denied'
                ]);

            $status = $request->get('status');
            $presentation = $this->repository->handleWrittenPaperEditRequest($presentation, $status);

            return response([
                'status' => true,
                'message' => 'Successfully changed submission status',
                'presentation' => $presentation
            ]);
        }
        catch (Exception $exception) {
            return $this->handleException($exception, __FUNCTION__, __CLASS__);
        }
    }


    /**
     * @throws Exception
     */
    public function handleEditRequest(Request $request, $id)
    {
        try {
            $presentation = Presentation::find($id);
            if (!$presentation)
                return response([
                    'status' => false,
                    'message' => 'Presentation not found'
                ]);

            $role = $request->get('role');
            if ($role != 'event_admin' && $role != 'event_reviewer' && $role != 'event_submitter')
                return response([
                    'status' => false,
                    'message' => 'Access denied'
                ]);

            $status = $request->get('status');
            $presentation = $this->repository->handleEditRequest($presentation, $status);

            return response([
                'status' => true,
                'message' => 'Successfully changed submission status',
                'presentation' => $presentation
            ]);
        }
        catch (Exception $exception) {
            return $this->handleException($exception, __FUNCTION__, __CLASS__);
        }
    }


    /**
     * @throws Exception
     */
    public function handleReviewerApprovedRequest(Request $request, $id)
    {
        try {

            $presentation = Presentation::find($id);
            if (!$presentation)
                return response([
                    'status' => false,
                    'message' => 'Presentation not found'
                ]);


            $role = $request->get('role');
            $event = $request->get('event');
            $user = authUser();

            $eventUser = getEventUser($event->id, $user->id);
            $eventRoles = $eventUser->roles->pluck('name')->toArray();
            if (!in_array($role, $eventRoles))
                return response([
                    'status' => false,
                    'message' => 'Access denied'
                ]);

            $comment = $request->get('comment') ? $request->get('comment') : '';

            $presentation = $this->repository->handleReviewerApprovedRequest($comment, $presentation);

            return response([
                'status' => true,
                'message' => 'reviewer approved presentation successfully',
                'presentation' => $presentation
            ]);
        }
        catch (Exception $exception) {
            return $this->handleException($exception, __FUNCTION__, __CLASS__);
        }
    }

    public function count(Request $request)
    {
        try {
            $role = $request->get('role');
            if ($role != 'event_admin')
                return response([
                    'status' => false,
                    'message' => 'Access denied'
                ]);

            $count = $this->repository->getPresentationCount($request);

            return response([
                'status' => true,
                'count' => $count
            ]);
        } catch (Exception $exception) {
            return $this->handleException($exception, __FUNCTION__, __CLASS__);
        }
    }

    public function previewFile(Request $request, $id, $fileId)
    {
        $file = File::whereId($fileId)
            ->whereModelId($id)
            ->whereModel(Presentation::class)
            ->first();
    
        if (!$file) {
            return response(['status' => false, 'message' => "File not found"]);
        }
    
        $originalPath = storage_path("app/" . $file->filepath . $file->save_name);
    
        if (!file_exists($originalPath)) {
            return response(['status' => false, 'message' => "Original file missing"]);
        }
    
        $publicPath = 'tmp-preview/' . Str::uuid() . '_' . $file->filename;
    
        // Copy to public disk (e.g., storage/app/public/tmp-preview)
        Storage::disk('public')->put($publicPath, file_get_contents($originalPath));
    
        $fileUrl = asset("storage/{$publicPath}");
    
        return response([
            'status' => true,
            'file' => [
                'filename' => $file->filename,
                'url' => $fileUrl,
            ]
        ]);
    }

    public function serveFile(Request $request, $fileId)
    {
        try {
           
            $fileRecord = File::findOrFail($fileId);
            $filePath = storage_path("app/" . $fileRecord->filepath . $fileRecord->save_name);
    
            if (!file_exists($filePath)) {
                abort(404, 'File not found');
            }
    
            // Determine correct MIME type
            $extension = strtolower(pathinfo($fileRecord->filename, PATHINFO_EXTENSION));
            $mimeTypes = [
                'ppt'  => 'application/vnd.ms-powerpoint',
                'pptx' => 'application/vnd.openxmlformats-officedocument.presentationml.presentation',
                // Add more types as needed
            ];
    
            $mimeType = $mimeTypes[$extension] ?? 'application/octet-stream';
    
            return response()->file($filePath, [
                'Content-Type' => $mimeType,
                'Content-Disposition' => 'inline; filename="' . $fileRecord->filename . '"'
            ]);
        } catch (Exception $e) {
            return response()->json(['status' => false, 'message' => $e->getMessage()], 500);
        }
    }
}
File Content: PresentationController.php

File Content: `PresentationController.php`
