~NAXC~

File Content: `AbstractsController.php`

<?php

namespace App\Http\Controllers;

use App\Jobs\SendAbstractSelected;
use App\Jobs\SendEditRequestMail;
use App\Models\Abstracts;
use App\Models\Event;
use App\Models\File;
use App\Models\Presentation;
use App\Models\Slot;
use App\Repositories\AbstractsRepository;
use App\Repositories\PresentationRepository;
use Exception;
use Illuminate\Database\Eloquent\Builder;
use Illuminate\Http\Request;
use Illuminate\Support\Facades\Storage;

class AbstractsController extends Controller
{
    protected AbstractsRepository $repository;

    public function __construct(AbstractsRepository $abstractsRepository)
    {
        $this->repository = $abstractsRepository;

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


    public function createOrUpdateAbstract(Request $request)
    {
        try {
            $eventUser = $request->get('event_user');

            $this->authorize('create', [Abstracts::class, $eventUser]);

            [$abstract, $message] = $this->repository->createOrUpdate($request);
            $abstract->users = $abstract->users()->get();

            $role = $request->get('role');

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

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

    public function view(Request $request, $id)
    {
        try {
            $role = $request->get('role');
            $abstract = $this->repository->fetchSingleAbstract($id, $role, $request);
            if (!$abstract)
                validationErrorResponse(['Invalid abstract id']);

            $this->authorize('view', [Abstracts::class, $abstract, $request->get('event_user'), $request->get('role')]);

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

            $response = [
                'status' => true,
                'abstract' => $abstract
            ];

            // finding next abstract id
            if ($role == 'event_reviewer' || $role == 'event_co_chair') {
                $request->merge([
                    'next' => true
                ]);
                $abstracts = $this->repository->listing($request, false);
                $abstractIds = $abstracts->pluck('id')->toArray();
                $scoreCounts = $abstracts->pluck('score_count')->toArray();
                $currentKey = array_search($id, $abstractIds);
                $nextKey = $currentKey + 1;
                while (isset($scoreCounts[$nextKey]) && $scoreCounts[$nextKey] != 0) {
                    $nextKey++;
                }
                $nextId = $abstractIds[$nextKey] ?? false;
                if (!$nextId) {
                    $nextKey = 0;
                    while (isset($scoreCounts[$nextKey]) && $scoreCounts[$nextKey] != 0) {
                        $nextKey++;
                    }
                    $nextId = $abstractIds[$nextKey] ?? false;
                }
                if ($nextId == $id)
                    $nextId = false;
                $response['next_id'] = $nextId;
            }

            return response($response);
        } catch (Exception $exception) {
            return $this->handleException($exception, __FUNCTION__, __CLASS__);
        }
    }

    /**
     * @OA\Get(
     *  path="/api/abstract/list",
     *  summary="Get the list of abstracts in an event",
     *  tags={"Abstract"},
     *  @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="strings")
     *  ),
     *     @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"",""submission_status"":""asc""}. Available column names id,submission_status,score,rank,step,created_at,submitter_name,no_of_votes and all abstract form fields(field_id).",
     *    @OA\Schema(type="json")
     *  ),
     *     @OA\Parameter(name="filter",
     *    in="query",
     *    required=false,
     *    description="Filter for abstract list. Inside one key you can send multiple values as array. eg. {""category"":[""Strategic Stream""],""company"":[""Phases"",""dmg""]}. Available filters are category, subcategory, company, submission_status ('submitted','draft'), selection_status ('Accepted','Rejected','Accepted Reserve','Provisionally Accepted, 'Provisionally Accepted Reserve'), score_min, score_max, no_of_votes_min, no_of_votes_max",
     *    @OA\Schema(type="json")
     *  ),
     *  @OA\Response(response="200",
     *    description="List of abstracts",
     *  )
     * )
     */
    public function list(Request $request)
    {
        try {
            $this->authorize('list', [Abstracts::class, $request->get('event_user')]);

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

            $role = $request->get('role');
            $paging = $request->get('paging', '10');
            $reviewerId = $request->get('reviewer_id', false);
            $idsOnly = $request->get('ids_only', false);
            $idsOnly = $idsOnly == 'true';

            if ($role == 'event_reviewer' || $role == 'event_co_chair' || ($role == 'event_admin' && $reviewerId)) {
                $abstracts = $data->pluck('id')->toArray();
                $reviewerId = $reviewerId ?: authUser()->id;
                $abstracts = Abstracts::with(['scores' => function ($query) use ($reviewerId) {
                    $query->where('user_id', '=', $reviewerId);
                }])->find($abstracts);

                if (!$idsOnly) {
                    //todo: need to optimize this
                    $abstracts->transform(function ($abstract) {
                        $abstract->users = $abstract->users;
                        return $abstract;
                    });

                    $total = $data->count();
                    $data = $data->toArray();
                    unset($data['links']);
                } else {
                    $total = $abstracts->count();
                    $abstracts = $abstracts->pluck('id')->toArray();
                }

                if ($paging == 'All')
                    $data = $abstracts;
                else
                    $data['data'] = $abstracts;
            } else {
                $total = $data->count();
                if (!$idsOnly) {
                    $data->transform(function ($item) {
                        $item->data = json_decode($item->data);
                        return $item;
                    });
                    $data = $data->toArray();
                    unset($data['links']);
                } else
                    $data = $data->pluck('id')->toArray();
            }

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

    /**
     * @param Request $request
     * @param $id
     * @return \App\Support\Entity|\Illuminate\Contracts\Foundation\Application|\Illuminate\Contracts\Routing\ResponseFactory|\Illuminate\Http\Response
     * @throws Exception
     */
    public function deleteAbstract(Request $request, $id)
    {
        try {
            $abstract = Abstracts::find($id);
            if (!$abstract)
                return response([
                    'status' => false,
                    'message' => 'Abstract not found'
                ]);

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

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

            if ($role === 'event_submitter') {
                $submitter = $abstract->users('abstract_submitter')->first();
                if ($user->id != $submitter->id)
                    return response([
                        'status' => false,
                        'message' => 'Access denied'
                    ]);
                if ($abstract->submission_status == 'submitted')
                    return response([
                        'status' => false,
                        'message' => 'Cannot delete submitted abstract'
                    ]);
            }

            return $this->repository->deleteAbstract($abstract);
        } catch (Exception $exception) {
            return $this->handleException($exception, __FUNCTION__, __CLASS__);
        }
    }

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

            $user = authUser();
            $submitter = $abstract->users('abstract_submitter')->first();
            if ($user->id != $submitter->id)
                return response([
                    'status' => false,
                    'message' => 'Access denied'
                ]);

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

            //sending mail to admins
            $this->dispatch(new SendEditRequestMail($abstract->event, $abstract, $submitter));

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

    /**
     * @throws Exception
     */
    public function handleEditRequest(Request $request, $id)
    {
        try {
            $abstract = $this->checkAdminAccess($request, $id);

            $status = $request->get('status');
            $abstract = $this->repository->handleEditRequest($abstract, $status);
            unset($abstract->event);

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

    public function checkAdminAccess(Request $request, $id)
    {
        $abstract = Abstracts::find($id);
        if (!$abstract)
            return response([
                'status' => false,
                'message' => 'Abstract not found'
            ]);

        $event = $request->get('event');
        $eventUser = $request->get('event_user');
        if ($abstract->event->id != $event->id || !$eventUser->hasRole('event_admin'))
            return response([
                'status' => false,
                'message' => 'Access denied'
            ], 401);
        return $abstract;
    }

    public function handleSelectionStatus(Request $request, $id)
    {
        try {
            $selectionStatus = $request->get('selection_status');

            if ($id == 'bulk') {
                $event = $request->get('event');
                $eventUser = $request->get('event_user');
                $sendEmailStatus = $request->get('send_email_status');

                if (!$eventUser->hasRole('event_admin'))
                    validationErrorResponse(['Access denied']);

                $ids = $request->get('ids');
                $abstracts = Abstracts::whereIn('id', $ids)
                    ->where('event_id', '=', $event->id)
                    ->get();
                if (count($ids) != count($abstracts))
                    validationErrorResponse(['Some abstracts not found']);

                $abstracts = Abstracts::whereIn('id', $ids)
                    ->where('event_id', '=', $event->id)
                    ->whereSubmissionStatus('submitted')
                    ->get();
                if (count($ids) != count($abstracts))
                    validationErrorResponse(['Some abstracts are not submitted']);

                $abstractIds = $abstracts->pluck('id')->toArray();
                Abstracts::whereIn('id', $abstractIds)
                    ->update([
                    'selection_status' => $selectionStatus
                ]);

                // send emails
                if ($sendEmailStatus) {
                    foreach ($abstracts as $abstract) {
                        // send abstract selected email
                        $this->dispatch(new SendAbstractSelected($abstract));
                    }
                }

                return response([
                    'status' => true,
                    'message' => "Successfully updated selection status"
                ]);
            }
            else {
                $abstract = $this->checkAdminAccess($request, $id);
                Abstracts::whereId($abstract->id)
                    ->update([
                    'selection_status' => $selectionStatus
                ]);
                $abstract->selection_status = $selectionStatus;

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

    /**
     * @param Request $request
     * @param $id
     * @return \App\Support\Entity|\Illuminate\Contracts\Foundation\Application|\Illuminate\Contracts\Routing\ResponseFactory|\Illuminate\Http\Response
     * @throws Exception
     */
    public function handlePresentationType(Request $request, $id)
    {
        try {
            $abstract = $this->checkAdminAccess($request, $id);
            $presentationType = $request->get('type');
            Abstracts::whereId($abstract->id)
                ->update([
                    'presentation_type' => $presentationType
                ]);
            $abstract->presentation_type = $presentationType;

            $presentation = Presentation::whereAbstractId($id)
                ->first();
            if ($presentation) {
                $presentation->presentation_type = $presentationType;
                $presentation->save();
            }

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

    public function emailSelectionStatus(Request $request, $id)
    {
        try {
            $abstract = $this->checkAdminAccess($request, $id);

            // if ($abstract->selection_status != 'Accepted' && $abstract->selection_status != 'Accepted Reserve')
            //     return response([
            //         'status' => false,
            //         'message' => "Invalid selection status"
            //     ]);

            /** @var Abstracts $abstract */
            $this->dispatch(new SendAbstractSelected($abstract));

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

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

            $abstractStatusCount = $this->repository->getAbstractStatusCount($request->get('event'))->get();
            $abstractCountryCount = $this->repository->getAbstractCountryCount($request->get('event'))->get();
            $abstractCompanyCount = $this->repository->getAbstractCompanyCount($request->get('event'))->get();
            $abstractCategoryCount = $this->repository->getAbstractCategoryCount($request->get('event'));
            $abstractSubcategoryCount = $this->repository->getAbstractSubcategoryCount($request->get('event'));

            return response([
                'status' => true,
                'abstract_status_count' => $abstractStatusCount[0],
                'abstract_country_count' => $abstractCountryCount,
                'abstract_company_count' => $abstractCompanyCount,
                'abstract_category_count' => $abstractCategoryCount,
                'abstract_subcategory_count' => $abstractSubcategoryCount

            ]);
        } catch (Exception $exception) {
            return $this->handleException($exception, __FUNCTION__, __CLASS__);
        }
    }

    /**
     * @OA\Get(
     *  path="/api/abstract/{id}/file/{fileId}",
     *  summary="Get the abstract file",
     *  tags={"Abstract"},
     *    @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="Abstract 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="Abstract File",
     *  )
     * )
     */
    public function downloadFile(Request $request, $id, $fileId)
    {
        try {
            $file = File::whereId($fileId)
                ->whereModelId($id)
                ->whereModel(Abstracts::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 export(Request $request)
    {
        try {

            ini_set('memory_limit', '-1');
            
            $this->authorize('list', [Abstracts::class, $request->get('event_user')]);

            $role = $request->get('role');
            $eventUser = $request->get('event_user');
            $timeZone = $request->get('timezone_offset');
            $event = $request->get('event');
            $isAwardSubmission = $event['general_settings']['award_submission_section']['submission_section'] ?? false;

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

            $abstractIds = $request->get('abstract_ids', false);
            if (!$abstractIds) {
                $data = $this->repository->listing($request, true);
                $abstractIds = $data->pluck('id')->toArray();
            }
            $abstracts = Abstracts::with('scores')->findMany($abstractIds);

            if ($abstracts->isEmpty())
                return response([
                    'status' => false,
                    'message' => "No Abstracts"
                ]);

            return $this->repository->exportAbstract($abstracts, $timeZone, $role, $eventUser, $isAwardSubmission);
        } catch (Exception $exception) {
            return $this->handleException($exception, __FUNCTION__, __CLASS__);
        }
    }

    public function pdfExport(Request $request)
    {
        try {

            ini_set('memory_limit', '-1');

            $this->authorize('list', [Abstracts::class, $request->get('event_user')]);

            $role = $request->get('role');

            $event = $request->get('event');
            $isAwardSubmission = $event['general_settings']['award_submission_section']['submission_section'] ?? false;


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

            $abstractIds = $request->get('abstract_ids', false);
            if (!$abstractIds) {
                $data = $this->repository->listing($request, true);
                $abstractIds = $data->pluck('id')->toArray();
            }
            $abstracts = Abstracts::with('scores')->findMany($abstractIds);

            if ($abstracts->isEmpty())
                return response([
                    'status' => false,
                    'message' => "No Abstracts"
                ]);

            return $this->repository->pdfExportAbstract($abstracts, $role, $event, $isAwardSubmission);
        } catch (Exception $exception) {
            return $this->handleException($exception, __FUNCTION__, __CLASS__);
        }
    }

    /**
     * @param Request $request
     * @param $id
     * @return \App\Support\Entity|\Illuminate\Contracts\Foundation\Application|\Illuminate\Contracts\Routing\ResponseFactory|\Illuminate\Http\Response
     * @throws Exception
     */
    public function handlePresentationInvitation(Request $request, $id)
    {
        try {
            $abstract = Abstracts::find($id);
            if (!$abstract)
                return response([
                    'status' => false,
                    'message' => 'Abstract not found'
                ]);

            if (($abstract->selection_status != 'Accepted' && $abstract->selection_status != 'Accepted Reserve') || $abstract->submission_status != 'submitted')
                return response([
                    'status' => false,
                    'message' => 'Abstract not selected'
                ]);

            $invitationResponse = $request->get('invitation_response');
            if (!$abstract->presentation_invite) {
                $termsAndConditionStatus = $request->get('tc_status');
                $abstract->presentation_invite = $invitationResponse;
                $abstract->presentation_tc_status = $termsAndConditionStatus;
                $abstract->presentation_invite_date = date('Y-m-d H:i:s', time());
                $abstract->save();
            }

            if ($invitationResponse == 'Accepted') {
                $presentationRepository = new PresentationRepository();
                $presentation = $presentationRepository->createOrUpdate($request, $abstract);
            }

            return response([
                'status' => true,
                'message' => 'Successfully update invitation',
            ]);
        } catch (Exception $exception) {
            return $this->handleException($exception, __FUNCTION__, __CLASS__);
        }
    }
}
File Content: AbstractsController.php

File Content: `AbstractsController.php`
