~NAXC~

File Content: `SessionController.php`

<?php

namespace App\Http\Controllers;

use App\Models\ChairPerson;
use App\Models\Event;
use App\Models\PublishedSession;
use App\Models\PublishedSessionHistory;
use App\Models\Session;
use App\Models\SessionUser;
use App\Models\Slot;
use App\Models\SlotUser;
use App\Models\User;
use Illuminate\Support\Collection;
use App\Repositories\SessionRepository;
use App\Repositories\SlotRepository;
use Carbon\CarbonPeriod;
use Exception;
use Illuminate\Support\Facades\Log;
use Illuminate\Http\Request;
use Illuminate\Support\Facades\DB;
use SebastianBergmann\Environment\Console;

class SessionController extends Controller
{
    protected $repository;

    public function __construct(SessionRepository $sessionRepository)
    {
        $this->repository = $sessionRepository;
        $this->middleware('event.user:event_admin|event_submitter');
    }

    /**
     * @OA\Get(
     *  path="/api/session/list",
     *  summary="Get the list of sessions in an event",
     *  tags={"Session"},
     *  @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="filter",
     *    in="query",
     *    required=false,
     *    description="Filter for session list. Inside one key you can send multiple values as array. eg. {""types"":[""Test"",""Test2""]}. Available filters are category,room,types",
     *    @OA\Schema(type="json")
     *  ),
     *  @OA\Response(response="200",
     *    description="List of sessions",
     *  )
     * )
     */
    public function list(Request $request)
    {
        try {
            // event
            $event = $request->get('event');
            // paging
            $paging = $request->get('paging', '10');
            // ids only
            $idsOnly = $request->get('ids_only', false);
            // event session from parameter
            $eventSession = $request->get('eventSession', false);
            // session overview
            $sessionOverview = $request->get('sessionOverview', false);
            // ids only
            $idsOnly = $idsOnly == 'true';


            //Session data formatting for confirmed speaker
            if ($eventSession || $sessionOverview) {

                // get all session dates
                $sessionDates = Session::select(DB::raw('DATE(start_date) AS start_date'), DB::raw('DATE(end_date) AS end_date'))
                    ->where('event_id', '=', $event->id)
                    ->orderBy('start_date', 'asc')
                    ->distinct()->get();

                if (!$sessionDates)
                    return response([
                        'status' => false,
                        'message' => "Invalid session"
                    ]);

                $dates = [];
                // get session period
                foreach ($sessionDates as $sessionDate) {
                    $period = CarbonPeriod::create($sessionDate['start_date'], $sessionDate['end_date']);
                    // Convert the period to an array of dates
                    $dates = array_unique(array_merge($dates, $period->toArray()));
                }

                // reordering index
                $resultDates = array_values($dates);

                $data = [];

                // loop result days
                foreach ($resultDates as $sessionDate) {

                    // formatting
                    $sessionDates = $sessionDate->format('Y-m-d');

                    // selecting session data
                    if ($sessionOverview) {
                        // Get the existing filter string from the request
                        $filterString = $request->input('filter', '');
                        // Parse the existing filter string into an array
                        $filter = json_decode($filterString, true);
                        // Create the merge array
                        $merge = ['session_date' => $sessionDates];
                        if ($filter) {
                            // Merge the arrays
                            $mergedFilter = array_merge($filter, $merge);
                        } else {
                            $mergedFilter = $merge;
                        }
                        // Convert the merged filter array back to a string
                        $mergedFilterString = json_encode($mergedFilter);
                        // Update the request with the merged filter string
                        $request->merge(['filter' => $mergedFilterString]);
                        // query
                        $query = $this->repository->listing($request, true);
                    } else {
                        // query - select only two items
                        $query = Session::select(
                            'sessions.title',
                            'sessions.id',
                        );
                        // checking session date
                        $query->where(function ($query) use ($sessionDates) {
                            $query->whereRaw('? between sessions.start_date and sessions.end_date', [$sessionDates]);
                            $query->orWhere('sessions.start_date', 'LIKE', '%' . $sessionDates . '%');
                        });

                        // session based on event id
                        $query->where('sessions.event_id', '=', $event->id)->distinct();
                    }

                    // get session
                    $session = $query->get();


                    // get  all details of session
                    if ($sessionOverview) {
                        $result = [];
                        foreach ($session as $sessionItem) {
                            $result = (json_decode($session, TRUE));
                        }

                        // formatting result
                        $data[] = [
                            'date' => $sessionDates,
                            'sessionsData' => $result
                        ];
                    }
                    // get resulted session title and id
                    else {
                        // result
                        $titleResults = [];
                        foreach ($session as $sessionItem) {
                            $titleResults[] = [
                                'title' => $sessionItem->title,
                                'session_id' => $sessionItem->id
                            ];
                        }

                        // formatting result
                        $data[] = [
                            'date' => $sessionDates,
                            'title' => $titleResults
                        ];
                    }
                }

                $total = count($data);

            } else {
                // normal listing
                $data = $this->repository->listing($request, true);
                if ($idsOnly) {
                    $data = $data->pluck('id')->toArray();
                }
                $total = $data->count();
            }


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


    /**
     * @OA\Get(
     *  path="/api/session/slot/list",
     *  summary="Get the list of slots in an event",
     *  tags={"Session"},
     *  @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="sort",
     *    in="query",
     *    required=false,
     *    description="Sort the list by columns. eg. {""id"":""asc""}. Multisort available eg. {""identifier"":""asc"",""title"":""asc""}. Available column names id,title,identifier,session_id,start_date,end_date,duration,type,slot_users,room.",
     *    @OA\Schema(type="json")
     *  ),
     *  @OA\Response(response="200",
     *    description="List of slots",
     *  )
     * )
     */
    public function listSlots(Request $request)
    {
        try {
            $slotRepository = new SlotRepository();
            $slots = $slotRepository->listing($request, true);

            $paging = $request->get('paging', '10');
            $idsOnly = $request->get('ids_only', false);
            $idsOnly = $idsOnly == 'true';
            $total = $slots->count();
            if ($idsOnly) {
                $slots = $slots->pluck('id')->toArray();
            }
            return response([
                'status' => true,
                'slots' => $paging == 'All' && !$idsOnly ? ['data' => $slots, 'total' => $total] : $slots
            ]);
        } catch (Exception $exception) {
            return $this->handleException($exception, __FUNCTION__, __CLASS__);
        }
    }

    public function createOrUpdate(Request $request)
    {
        try {
            $event = $request->get('event');

            if (!$event)
                return response([
                    'status' => false,
                    'message' => "Invalid Event"
                ]);

            $session = $this->repository->createOrUpdate($request);

            $session = $this->repository->getSession($session->id, $event->id);

            activity('abstract.createOrUpdate')
                ->performedOn($session)
                ->causedBy(authUser())
                ->log('Admin submitted session');

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

    public function view(Request $request, $id)
    {
        try {
            $event = $request->get('event');

            if (!$event)
                return response([
                    'status' => false,
                    'message' => "Invalid Event"
                ]);

            $session = $this->repository->getSession($id, $event->id);
            if (!$session)
                return response([
                    'status' => false,
                    'message' => "Invalid session id"
                ]);

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

    /**
     * @OA\Delete(
     *  path="/api/session/{id}",
     *  summary="Delete a session (external access enabled)",
     *  tags={"Session"},
     *  @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,
     *    @OA\Schema(type="integer")
     *  ),
     *  @OA\Response(response="200",
     *    description="Session deleted successfully",
     *    @OA\JsonContent(
     *       @OA\Property(property="status", type="boolean", example=true),
     *       @OA\Property(property="message", type="string", example="Successfully deleted session")
     *    )
     *  )
     * )
     */
    public function delete(Request $request, $id)
    {
        try {
            $event = $request->get('event');
            $session = Session::find($id);
            if (!$session)
                return response([
                    'status' => false,
                    'message' => "Invalid id"
                ]);

            if ($event->id != $session->event_id)
                return response([
                    'status' => false,
                    'message' => "Invalid session"
                ]);

            $this->repository->delete($session);

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

    /**
     * Toggle exclude from print
     */
    public function toggleExcludeFromPrint(Request $request, $id)
    {
        $session = Session::findOrFail($id);
        $session->exclude_from_print = !$session->exclude_from_print;
        $session->save();

        return response()->json([
            'status' => true,
            'exclude_from_print' => $session->exclude_from_print,
        ]);
    }

    /**
     * session publish
     */
    public function publish(Request $request)
    {
        try {
            // Retrieve inputs from the request
            $event = $request->get('event');
            $sessionId = $request->get('id');
            $sessionIds = $request->get('ids');
            $role = $request->get('role');

            // Validate role
            if ($role !== 'event_admin') {
                return response()->json([
                    'status' => false,
                    'message' => 'Access denied'
                ]);
            }

            // Check if either session ID or session IDs are present
            if (!$sessionId && !$sessionIds) {
                return response()->json([
                    'status' => false,
                    'message' => 'No session ID(s) provided'
                ]);
            }

            // Ensure event is present
            if (!$event) {
                return response()->json([
                    'status' => false,
                    'message' => 'Event not found'
                ]);
            }

            // Publish single session if session ID is provided
            if ($sessionId) {
                // Call function to publish single session
                $response = $this->publishSingleSession($sessionId, $event);
            } else {
                // Call function to publish global sessions
                $response = $this->publishGlobalSessions($sessionIds, $event);
            }

            // Return the response
            return $response;

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

    // Function to publish a single session
    private function publishSingleSession($sessionId, $event)
    {
        // Find the session by ID
        $session = Session::find($sessionId);
        // Check if the session exists and belongs to the event
        if (!$session || $event->id != $session->event_id) {
            // Return error response if session is invalid or not found
            return response()->json([
                'status' => false,
                'message' => 'Invalid session ID or session not found'
            ]);
        }

        // Publish the session
        $this->repository->publish($session);

        // Return success response
        return response()->json([
            'status' => true,
            'message' => 'Session published successfully'
        ]);
    }

    // Function to publish global sessions
    private function publishGlobalSessions($sessionIds, $event)
    {
        // Iterate over each session ID
        foreach ($sessionIds as $id) {
            // Find the session by ID
            $session = Session::find($id);
            // Check if the session exists and belongs to the event
            if (!$session || $event->id != $session->event_id) {
                continue; // Skip invalid or mismatched sessions
            }
            if (!$session->published_status) {
                // Publish the session
                $this->repository->publish($session);
            }
        }

        // Return success response
        return response()->json([
            'status' => true,
            'message' => 'All sessions published successfully'
        ]);
    }

    /**
     * get session dates
     */
    public function sessionsDates(Request $request)
    {
        try {
            $event = $request->get('event');
            $role = $request->get('role');
            if (!$event)
                return response([
                    'status' => false,
                    'message' => "Invalid event"
                ]);

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

            $query = Session::select(DB::raw('DATE(start_date) AS start_date'), DB::raw('DATE(end_date) AS end_date'))->where('event_id', '=', $event->id)->orderBy('start_date', 'asc')
                ->distinct();

            $arguments = $this->repository->arguments($request);
            $query = $this->repository->applyFilter($query, $arguments);
            $sessionDates = $query->get();

            if (!$sessionDates)
                return response([
                    'status' => false,
                    'message' => "Invalid session"
                ]);

            $dates = [];
            foreach ($sessionDates as $sessionDate) {
                $period = CarbonPeriod::create($sessionDate['start_date'], $sessionDate['end_date']);
                // Convert the period to an array of dates
                $dates = array_unique(array_merge($dates, $period->toArray()));
            }

            // reordering index
            $resultDates = array_values($dates);

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

    /**
     * @OA\Get(
     *  path="/api/session/published-sessions",
     *  summary="Get the list of published sessions in an event",
     *  tags={"Published Session"},
     *  @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="filter",
     *    in="query",
     *    required=false,
     *    description="Filter for published session list. You can filter published session using session date and last synced date. eg. {""session_date"":""2022-07-21"",""last_synced_date"":""2022-07-21""}.",
     *    @OA\Schema(type="json")
     *  ),
     *  @OA\Response(response="200",
     *    description="List of published sessions",
     *  )
     * )
     */
    public function publishedSessions(Request $request)
    {
        try {
            // event
            $event = $request->get('event');
            // if 2 events will get event ids here
            $multiEvent = $request->get('eventIds');
            // role
            $role = $request->get('role');

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

            // Handle single event slug or multiple event slugs
            $eventIds = $multiEvent
                ? $multiEvent
                : [$event->id];


            if (!$eventIds) {
                return response([
                    'status' => false,
                    'message' => "No events found"
                ]);
            }

            // Fetch published sessions for all found events
            $data = $this->repository->publishedSessions($request, $eventIds, true);

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

            $total = $data->count();

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

    public function getFilterOptions(Request $request)
    {
        try {
            $event = $request->get('event');

            $options = $this->repository->getFilterOptions($event);
            
            // Add session categories if session form settings are enabled
            if ($event->general_settings['session_form_settings']['enabled'] ?? false) {
                $sessionCategories = [];
                $categories = $event->general_settings['session_form_settings']['categories'] ?? [];
                
                foreach ($categories as $category) {
                    foreach ($category['category_options'] ?? [] as $option) {
                        $sessionCategories[] = $option['option_label'];
                    }
                }
                
                $options['session_categories'] = array_unique($sessionCategories);
            }

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

    public function getMySessions(Request $request)
    {
        try {

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

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

            $data = $this->repository->getMySessions($request);

            $total = $data->count();

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

    /**
     * @OA\Get(
     *  path="/api/session/category-settings/list",
     *  summary="Get the list of session categories in an event",
     *  tags={"Session"},
     *  @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\Response(response="200",
     *    description="List of session categories",
     *  )
     * )
     */
    public function getAllSessionFormSettingsCategories(Request $request)
    {
        try {
            // role
            $role = $request->get('role');
            // event
            $event = $request->get('event');

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

            //general settings
            $generalSettings = $event->general_settings;
            // session settings categories list
            $data = $generalSettings['session_form_settings'];

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

    /**
     * @OA\Get(
     *  path="/api/session/room-type-options/list",
     *  summary="Get the list of session room and track/type options in an event",
     *  tags={"Session"},
     *  @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\Response(response="200",
     *    description="List of room and track/type options",
     *  )
     * )
     */
    public function getSessionRoomAndTypeOptions(Request $request)
    {
        try {
            // role
            $role = $request->get('role');
            // event
            $event = $request->get('event');

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

            //general settings
            $generalSettings = $event->general_settings;
            // session room and type/track options list
            $data = $generalSettings['session_room_type_fields'];

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

    // create or update chairperson
    public function createOrUpdateChairPerson(Request $request)
    {
        try {
            $event = $request->get('event');

            if (!$event)
                return response([
                    'status' => false,
                    'message' => "Invalid Event"
                ]);
            // create or update
            $chairPerson = $this->repository->createOrUpdateChairPerson($request, $event);

            return response([
                'status' => true,
                'message' => "ChairPerson saved successfully",
                'chairPerson' => $chairPerson
            ]);
        } catch (Exception $exception) {
            return $this->handleException($exception, __FUNCTION__, __CLASS__);
        }
    }
    /**
     * @OA\Get(
     *  path="/api/session/chair-person/list",
     *  summary="Get the list of chairpersons in an event",
     *  tags={"Session"},
     *  @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="filter",
     *    in="query",
     *    required=false,
     *    description="Filter for chairperson list. You can filter chairperson using session date. eg. {""session_date"":""2022-07-21""}.",
     *    @OA\Schema(type="json")
     *  ),
     *  @OA\Response(response="200",
     *    description="List of chairpersons",
     *  )
     * )
     */
    // list chairpersons
    public function listChairPersons(Request $request)
    {
        try {
            $event = $request->get('event');
            $role = $request->get('role');

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

            if (!$event)
                return response([
                    'status' => false,
                    'message' => "Invalid event"
                ]);
            // chairPersons
            $chairPersons = $this->repository->listChairPersons($request, $event, true);

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

    // delete chairperson
    public function deleteChairPerson(Request $request, $id)
    {
        try {
            $chairPerson = ChairPerson::find($id);

            if (!$chairPerson) {
                return response([
                    'status' => false,
                    'message' => 'Chair person not found',
                ]);
            }

            $chairPerson->delete();

            return response([
                'status' => true,
                'message' => 'Chair person deleted successfully',
            ]);
        } catch (Exception $exception) {
            // Handle exceptions if necessary
            return response([
                'status' => false,
                'message' => 'Error deleting chair person',
            ]);
        }
    }

    public function exportSessions(Request $request)
    {
        try {
            ini_set('memory_limit', '-1');
            // role
            $role = $request->get('role');
            //event
            $event = $request->get('event');
            // not role is event admin return access denied
            if ($role != 'event_admin')
                return response([
                    'status' => false,
                    'message' => "Access denied"
                ]);

            // invalid event return
            if (!$event)
                return response([
                    'status' => false,
                    'message' => "Invalid event"
                ]);
            // all sessions in an event
            $query = Session::where('event_id', '=', $event->id);
            // arguments
            $arguments = $this->repository->arguments($request);
            // filter
            $query = $this->repository->applyFilter($query, $arguments);
            // sessions
            $sessions = $query->orderBy('start_date', 'asc')->get();

            // session is empty returning no sessions found message
            if ($sessions->isEmpty())
                return response([
                    'status' => false,
                    'message' => "No Sessions Found"
                ]);
            // export session function
            return $this->repository->exportSessions($sessions);
        } catch (Exception $exception) {
            return $this->handleException($exception, __FUNCTION__, __CLASS__);
        }
    }

    /**
     * @OA\Post(
     *  path="/api/session/bulk",
     *  summary="Bulk create or update sessions. Include 'id' only for updates, omit for new sessions.",
     *  tags={"Session"},
     *  @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\RequestBody(
     *    required=true,
     *    description="Sessions data for bulk creation/update. Include 'id' field only for updating existing sessions. Omit 'id' field for creating new sessions.",
     *    @OA\JsonContent(
     *       required={"sessions"},
     *       @OA\Property(property="sessions", type="array", 
     *         example={
     *           {
     *             "start_date": "2024-01-15 09:00:00",
     *             "end_date": "2024-01-15 10:30:00",
     *             "title": "AI in Healthcare",
     *             "type": "Keynote",
     *             "room": "Room 1",
     *             "category": "Technology",
     *             "hide_session": false,
     *             "description": "Session about AI applications",
     *             "heading": "Welcome to AI Session",
     *             "published": true
     *           },
     *           {
     *             "id": 124,
     *             "start_date": "2024-01-15 11:00:00",
     *             "end_date": "2024-01-15 12:00:00",
     *             "title": "Machine Learning Workshop",
     *             "type": "Workshop",
     *             "room": "Room 2",
     *             "category": "Technology",
     *             "hide_session": false,
     *             "description": "<p>Hands-on ML workshop</p>",
     *             "description2": "Advanced techniques covered",
     *             "sub_heading": "Interactive Learning",
     *             "published": false
     *           }
     *         },
     *         @OA\Items(
     *         @OA\Property(property="id", type="integer", description="[OPTIONAL] Session ID - Include ONLY for updating existing sessions. Omit completely for creating new sessions."),
     *         @OA\Property(property="start_date", type="string", description="Session start date and time"),
     *         @OA\Property(property="end_date", type="string", description="Session end date and time"),
     *         @OA\Property(property="title", type="string", description="Session title"),
     *         @OA\Property(property="type", type="string", description="Session type/track"),
     *         @OA\Property(property="room", type="string", description="Session room (must match available room options from your event settings)"),
     *         @OA\Property(property="category", type="string", description="Session category"),
     *         @OA\Property(property="hide_session", type="boolean", description="Hide session on website"),
     *         @OA\Property(property="description", type="string", description="Main session description (HTML format - plain text auto-converted to <p> tags)"),
     *         @OA\Property(property="description2", type="string", description="Secondary description (HTML format - plain text auto-converted to <p> tags)"),
     *         @OA\Property(property="heading", type="string", description="Session heading (plain text only - no HTML conversion)"),
     *         @OA\Property(property="sub_heading", type="string", description="Session sub-heading (plain text only - no HTML conversion)"),
     *         @OA\Property(property="published", type="boolean", description="Whether to publish the session immediately")
     *       ))
     *    ),
     * ),
     *  @OA\Response(response="200",
     *    description="Create/Update sessions",
     *  )
     * )
     */
    public function bulkCreateOrUpdate(Request $request)
    {
        try {
            $event = $request->get('event');
            $role = $request->get('role');

            if ($role !== 'event_admin') {
                return response([
                    'status' => false,
                    'message' => 'Access denied'
                ], 403);
            }

            if (!$event) {
                return response([
                    'status' => false,
                    'message' => 'Invalid Event'
                ], 400);
            }

            $input = $request->input();
            $sessionsData = $input['sessions'] ?? [];

            if (empty($sessionsData)) {
                return response([
                    'status' => false,
                    'message' => 'No sessions provided'
                ], 400);
            }

            $results = $this->repository->bulkCreateOrUpdate($sessionsData, $event);

            return response([
                'status' => true,
                'message' => 'Sessions processed successfully',
                'sessions' => $results
            ]);

        } catch (\Exception $exception) {
            $errorData = json_decode($exception->getMessage(), true);

            // Handle multiple validation errors (new format)
            if ($errorData && isset($errorData['type']) && $errorData['type'] === 'validation_errors') {
                return response([
                    'status' => false,
                    'message' => $errorData['message'],
                    'errors' => $errorData['errors']
                ], 400)->header('Cache-Control', 'no-cache, no-store, must-revalidate');
            }

            // Handle single validation error (legacy format - for backward compatibility)
            if ($errorData && isset($errorData['session_title'])) {
                return response([
                    'status' => false,
                    'session_title' => $errorData['session_title'],
                    'errors' => $errorData['errors']
                ], 400)->header('Cache-Control', 'no-cache, no-store, must-revalidate');
            }

            return $this->handleException($exception, __FUNCTION__, __CLASS__);
        }
    }



    /**
     * @OA\Get(
     *  path="/api/session/previous-published-sessions",
     *  summary="Get the list of previous published sessions",
     *  tags={"Previous Published Session"},
     *  @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="session_id",
     *    in="query",
     *    required=true,
     *    @OA\Schema(type="integer")
     *  ),
     *  @OA\Response(response="200",
     *    description="List of previous published sessions",
     *  )
     * )
     */
    public function previousPublishedSessions(Request $request)
    {
        // event
        $event = $request->get('event');
        // role
        $role = $request->get('role');
        // session id
        $sessionId = $request->get('session_id');

        // not role is event admin return access denied
        if ($role != 'event_admin')
            return response([
                'status' => false,
                'message' => "Access denied"
            ]);

        // invalid event return
        if (!$event)
            return response([
                'status' => false,
                'message' => "Invalid event"
            ]);

        // published session
        $publishedSession = PublishedSession::where('event_id', $event->id)
            ->where('session_id', $sessionId)
            ->first();

        // invalid event return
        if (!$publishedSession)
            return response([
                'status' => false,
                'message' => "Invalid session"
            ]);

        $histories = PublishedSessionHistory::with('publisher')
            ->where('published_session_id', $publishedSession->id)
            ->orderByDesc('published_date')
            ->limit(5)
            ->get()
            ->map(function ($history, $index) {
                return [
                    'published_data' => $history->published_data,
                    'published_date' => $history->published_date ? date('Y-m-d H:i:s', strtotime($history->published_date)) : null,
                    'published_by' => $history->publisher ? $history->publisher->email : null,
                    'previous_session_order' => $index + 1,
                ];
            });


        return response([
            'status' => true,
            'previously_published_sessions' => $histories,
        ]);
    }
}
File Content: SessionController.php

File Content: `SessionController.php`
