# 2. RmController — `app/Http/Controllers/RmController.php`

## Current State

The controller has 3 methods: `rmRequests`, `rmRequestsDetails`, `getRmData`.
Uses models: `RmModel`, `RmConversation`.

## Changes

### 2a. Add new imports (top of file, after existing `use` statements)

```php
use App\Models\EventModel;
use App\Models\EventServices;
use App\Models\Countries;
use App\Models\States;
use App\Models\Cities;
use App\Models\ServiceModel;
use App\Models\CategoryModel;
use Illuminate\Support\Str;
use DB, Session, Log;
```

Current imports (lines 3-9):
```php
namespace App\Http\Controllers;
use Illuminate\Http\Request;
use App\Models\RmModel;
use App\Models\RmConversation;
```

After change:
```php
namespace App\Http\Controllers;
use Illuminate\Http\Request;
use App\Models\RmModel;
use App\Models\RmConversation;
use App\Models\EventModel;
use App\Models\EventServices;
use App\Models\Countries;
use App\Models\States;
use App\Models\Cities;
use App\Models\ServiceModel;
use App\Models\CategoryModel;
use Illuminate\Support\Str;
use DB, Session, Log;
```

---

### 2b. Add `createEventForm` method (after `rmRequestsDetails` method, before `getRmData`)

```php
public function createEventForm(Request $request, $id)
{
    $rmDetails = RmModel::where('uuid', $id)
        ->with('getEventDetails', 'categoryDetails', 'clientDetails')
        ->first();

    if (!$rmDetails) {
        Session::flash('msg', 'RM Request not found');
        Session::flash('alert-class', 'alert-danger');
        return redirect('/rm/rm-requests');
    }

    // If event already exists for this RM request, redirect back
    if ($rmDetails->record_type == 'event' && !empty($rmDetails->getEventDetails)) {
        Session::flash('msg', 'Event already exists for this RM request');
        Session::flash('alert-class', 'alert-warning');
        return redirect('/rm/rm-request-details/' . $id);
    }

    // Fetch dropdown data
    $countries = Countries::where('status', 1)->get(['id', 'name']);
    $states = States::where('status', 1)->get(['id', 'name', 'country_id']);
    $cities = Cities::where('status', 1)
        ->where('state_id', $rmDetails->state_id)
        ->get(['id', 'name']);
    $services = ServiceModel::where('status', 1)->orderBy('name', 'asc')->get(['id', 'name']);
    $categories = CategoryModel::all(['id', 'name', 'type']);

    $title = 'Create Event';
    $breadcrumb = '';
    $js_file = 'createEvent.js';

    return view('rm.createEvent', [
        'title'      => $title,
        'breadcrumb' => $breadcrumb,
        'js_file'    => $js_file,
        'rmDetails'  => $rmDetails,
        'countries'  => $countries,
        'states'     => $states,
        'cities'     => $cities,
        'services'   => $services,
        'categories' => $categories,
    ]);
}
```

**Key decisions:**
- Guard clause: redirect if event already exists for this RM request
- Cities pre-filtered by RM's `state_id` so the dropdown is populated on page load
- All dropdown data passed server-side (no initial AJAX needed)
- Categories passed as full collection — JS will filter by type (personal/corporate)

---

### 2c. Add `storeEvent` method (after `createEventForm`)

```php
public function storeEvent(Request $request)
{
    $request->validate([
        'rm_request_uuid' => 'required|string',
        'client_id'       => 'required|integer',
        'type'            => 'required|string|in:personal,professional',
        'category'        => 'required|integer',
        'country_id'      => 'required|integer',
        'state_id'        => 'required|integer',
        'cities_id'       => 'required|integer',
        'event_name'      => 'required|string|max:100',
        'event_date'      => 'required|date',
        'event_start_time'=> 'required',
        'guest_count'     => 'required|integer',
        'description'     => 'required|string|max:500',
        'services'        => 'required|array|min:1',
        'services.*.id'   => 'required|integer',
        'services.*.budget' => 'required|numeric|min:0',
    ]);

    $rmRequestUuid = $request->rm_request_uuid;

    try {
        DB::beginTransaction();

        // 1. Generate unique human_usable_id (same logic as API)
        do {
            $randomNumber = mt_rand(1, 999999999);
            $humanUsableId = 'EVN' . str_pad($randomNumber, 9, '0', STR_PAD_LEFT);
        } while (EventModel::where('human_usable_id', $humanUsableId)->exists());

        // 2. Create Event
        $event = new EventModel();
        $event->uuid              = Str::uuid()->toString();
        $event->human_usable_id   = $humanUsableId;
        $event->client_id         = $request->client_id;
        $event->type              = $request->type;
        $event->category          = $request->category;
        $event->country_id        = $request->country_id;
        $event->state_id          = $request->state_id;
        $event->cities_id         = $request->cities_id;
        $event->event_name        = $request->event_name;
        $event->description       = $request->description;
        $event->event_date        = $request->event_date;
        $event->event_start_time  = $request->event_start_time;
        $event->guest_count       = $request->guest_count;
        $event->save();

        // 3. Create Event Services
        foreach ($request->services as $service) {
            $eventService = new EventServices();
            $eventService->uuid                = Str::uuid()->toString();
            $eventService->event_id            = $event->id;
            $eventService->service_id          = $service['id'];
            $eventService->expected_event_date = $event->event_date;
            $eventService->expected_start_time = $event->event_start_time;
            $eventService->save();
        }

        // 4. Update RM Request — link to created event
        $rmRequest = RmModel::where('uuid', $rmRequestUuid)->first();
        if ($rmRequest) {
            $rmRequest->record_id   = $event->uuid;
            $rmRequest->event_id    = $event->uuid;
            $rmRequest->record_type = 'event';
            $rmRequest->status      = 2; // "Event Created" per rmStatus() helper
            $rmRequest->save();
        }

        DB::commit();

        Session::flash('msg', 'Event created successfully');
        Session::flash('alert-class', 'alert-success');

    } catch (\Exception $e) {
        DB::rollback();
        Log::error('Admin create event: Line - ' . $e->getLine() . ' ' . $e->getMessage());

        Session::flash('msg', 'Something went wrong! ' . $e->getMessage());
        Session::flash('alert-class', 'alert-danger');
    }

    return redirect('/rm/rm-request-details/' . $rmRequestUuid);
}
```

**Key decisions:**

1. **Validation** — mirrors the API's validation rules; adds `services.*.id` and `services.*.budget` for nested array
2. **human_usable_id** — uses `EVN` prefix + 9-digit padded random (same as API's `config('mvp.event_pre_fix')` which is `EVN`)
3. **UUID** — uses `Str::uuid()` (same pattern as `UsersController::createAccount`)
4. **event_services.event_id** — stores `$event->id` (integer FK per migration schema: `$table->unsignedBigInteger('event_id')->references('id')->on('events')`)
5. **event_services.service_id** — stores integer service ID (FK per migration)
6. **RM status** — set to `2` which maps to "Event Created" in `rmStatus()` helper (GlobalMethods.php:306-307)
7. **record_id / event_id on RM** — set to event UUID (matches RmModel's `getEventDetails` relationship which joins on `uuid = record_id`)
8. **Session flash** — follows existing pattern throughout VisoAdmin
9. **Redirect** — back to RM details page where the event info will now display

---

## Full File After Changes

```php
<?php

namespace App\Http\Controllers;

use Illuminate\Http\Request;

use App\Models\RmModel;
use App\Models\RmConversation;
use App\Models\EventModel;
use App\Models\EventServices;
use App\Models\Countries;
use App\Models\States;
use App\Models\Cities;
use App\Models\ServiceModel;
use App\Models\CategoryModel;
use Illuminate\Support\Str;
use DB, Session, Log;

class RmController extends Controller
{
    public function rmRequests(Request $request){
        // ... unchanged ...
    }

    public function rmRequestsDetails(Request $request,$id){
        // ... unchanged ...
    }

    public function createEventForm(Request $request, $id)
    {
        // ... as shown above ...
    }

    public function storeEvent(Request $request)
    {
        // ... as shown above ...
    }

    public function getRmData(Request $request){
        // ... unchanged ...
    }
}
```