DoorsController.php

<?php


namespace App\Http\Controllers\Web\Admin;

use Illuminate\Contracts\View\View;
use App\Http\Controllers\Controller;
use Illuminate\Http\RedirectResponse;
use Source\Exceptions\EntityExistsException;
use Illuminate\Validation\ValidationException;
use Source\UseCases\Doors\GetDoor\GetDoorUseCase;
use Source\UseCases\Doors\GetDoors\GetDoorsUseCase;
use Source\UseCases\Groups\GetGroups\GetGroupsUseCase;
use Source\UseCases\Doors\CreateDoor\CreateDoorUseCase;
use Source\UseCases\Doors\DeleteDoor\DeleteDoorUseCase;
use Source\UseCases\Doors\UpdateDoor\UpdateDoorUseCase;
use Source\UseCases\DoorUser\UserDoorAccess\UsersWebPresenter;
use Source\UseCases\Doors\CreateDoor\WebTokenGeneratePresenter;
use Source\UseCases\DoorGroup\GetDoorGroups\GetDoorGroupsUseCase;
use Source\UseCases\DoorUser\UserDoorAccess\UserDoorAccessUseCase;
use Source\UseCases\DoorGroup\AddDoorToGroup\AddDoorToGroupUseCase;
use Source\UseCases\Doors\GetDoor\APIPresenter as GetDoorPresenter;
use Source\UseCases\Doors\GenerateDoorToken\GenerateDoorTokenUseCase;
use Source\UseCases\Doors\GetDoors\WebPresenter as GetDoorsPresenter;
use Source\UseCases\Groups\GetGroups\WebPresenter as GroupsPresenter;
use Source\UseCases\Doors\CreateDoor\WebPresenter as CreateDoorPresenter;
use Source\UseCases\Doors\DeleteDoor\APIPresenter as DeleteDoorPresenter;
use Source\UseCases\Doors\UpdateDoor\APIPresenter as UpdateDoorPresenter;
use Source\UseCases\DoorGroup\RemoveDoorFromGroup\RemoveDoorFromGroupUseCase;
use Source\UseCases\DoorGroup\AddDoorToGroup\APIPresenter as DoorGroupPresenter;
use Source\UseCases\DoorGroup\GetDoorGroups\WebPresenter as DoorGroupsPresenter;
use Source\UseCases\DoorGroup\RemoveDoorFromGroup\APIPresenter as RemoveDoorGroupPresenter;

class DoorsController extends Controller
{
    /**
     * Since a checkbox input sends "on" when selected and null when not selected.
     * So here if it is set to "on" we turn it to false, and if it is not present, we set it to false.
     */
    protected function processPublicField(): void
    {
        if (!$this->request->has('public')) {
            $this->request['public'] = false;
        } else {
            $this->request['public'] = true;
        }
    }

    /**
     * @param \Source\UseCases\Doors\GetDoors\GetDoorsUseCase $doors
     * @return \Illuminate\Contracts\View\View
     * @throws \Illuminate\Validation\ValidationException
     */
    public function index(GetDoorsUseCase $doors): View
    {
        $this->validate($this->request, [
            'query' => 'nullable|string',
            'awol_seconds' => 'nullable|int',
            'active_seconds' => 'nullable|int',
        ]);

        $presenter = new GetDoorsPresenter();
        $doors->query($this->request->all(), false, $presenter);

        return view('admin.doors', $presenter->getViewModel($this->request->all()));
    }

    /**
     * @param string                                        $doorId
     * @param \Source\UseCases\Doors\GetDoor\GetDoorUseCase $getDoor
     * @return \Illuminate\Contracts\View\View
     * @throws \Source\Exceptions\EntityNotFoundException
     */
    public function edit(string $doorId, GetDoorUseCase $getDoor): View
    {
        $presenter = new GetDoorPresenter();

        $getDoor->get($doorId, $presenter);

        $door = $presenter->getViewModel()['door'];

        $this->request->session()->flashInput($door);

        return view('admin.entities.door', ['id' => $door['id']]);
    }

    /**
     * @param string                                              $doorId
     * @param \Source\UseCases\Doors\UpdateDoor\UpdateDoorUseCase $updateDoor
     * @return \Illuminate\Http\RedirectResponse
     * @throws \Illuminate\Validation\ValidationException
     * @throws \Source\Exceptions\EntityNotFoundException
     */
    public function update(string $doorId, UpdateDoorUseCase $updateDoor): RedirectResponse
    {
        $this->processPublicField();

        $this->validate($this->request, [
            'location' => 'required|string|max:255',
            'name' => 'required|string|max:255',
            'public' => 'required|boolean',
            'notes' => 'nullable|string|max:255',
        ]);

        $presenter = new UpdateDoorPresenter();
        try {
            $updateDoor->update($doorId, $this->request->all(), $presenter);
        } catch (EntityExistsException $e) {
            throw ValidationException::withMessages(['errors' => $e->getMessage()]);
        }

        return redirect(route('web.admin.doors.index'))->with($presenter->getViewModel());
    }

    /**
     * @param \Source\UseCases\Doors\CreateDoor\CreateDoorUseCase $createDoor
     * @return \Illuminate\Http\RedirectResponse
     * @throws \Illuminate\Validation\ValidationException
     */
    public function store(CreateDoorUseCase $createDoor): RedirectResponse
    {
        $this->processPublicField();

        $this->validate($this->request, [
            'location' => 'required|string|max:255',
            'name' => 'required|string|max:255',
            'public' => 'required|boolean',
            'notes' => 'nullable|string|max:255',
        ]);

        $presenter = new CreateDoorPresenter();

        try {
            $createDoor->create($this->request->all(), $presenter);
        } catch (EntityExistsException $e) {
            throw ValidationException::withMessages(['errors' => $e->getMessage()]);
        }

        return redirect(route('web.admin.doors.index'))->with($presenter->getViewModel());
    }

    /**
     * @param string                                              $doorId
     * @param \Source\UseCases\Doors\DeleteDoor\DeleteDoorUseCase $deleteDoor
     * @return \Illuminate\Http\RedirectResponse
     * @throws \Source\Exceptions\EntityNotFoundException
     */
    public function destroy(string $doorId, DeleteDoorUseCase $deleteDoor): RedirectResponse
    {
        $presenter = new DeleteDoorPresenter();

        $deleteDoor->delete($doorId, $presenter);

        return redirect()->back()->with($presenter->getViewModel());
    }

    /**
     * @param string                                                            $doorId
     * @param \Source\UseCases\Doors\GenerateDoorToken\GenerateDoorTokenUseCase $tokenGenerator
     * @return \Illuminate\Http\RedirectResponse
     * @throws \Source\Exceptions\EntityNotFoundException
     * @throws \Illuminate\Validation\ValidationException
     */
    public function regenerateToken(string $doorId, GenerateDoorTokenUseCase $tokenGenerator): RedirectResponse
    {
        $presenter = new WebTokenGeneratePresenter();

        try {
            $tokenGenerator->generate($doorId, $presenter);
        } catch (EntityExistsException $e) {
            throw ValidationException::withMessages(['error' => 'Please re-perform this action. ' . $e->getMessage()]);
        }

        return redirect()->back()->with($presenter->getViewModel());
    }

    /**
     * @param string $doorId
     * @return \Illuminate\View\View
     */
    public function schedule(string $doorId): View
    {
        return view('admin.entities.doorAccess', ['id' => $doorId]);
    }

    /**
     * @param string                                                        $doorId
     * @param \Source\UseCases\DoorGroup\GetDoorGroups\GetDoorGroupsUseCase $doorGroups
     * @param \Source\UseCases\Groups\GetGroups\GetGroupsUseCase            $groups
     * @return \Illuminate\Contracts\View\View
     * @throws \Source\Exceptions\EntityNotFoundException
     */
    public function groups(string $doorId, GetDoorGroupsUseCase $doorGroups, GetGroupsUseCase $groups): View
    {
        $groupsPresenter = new GroupsPresenter();

        $groups->search(null, $groupsPresenter);

        $presenter = new DoorGroupsPresenter();

        $doorGroups->getGroupsForDoor($doorId, $presenter);

        return view('layouts.admin.groups', array_merge(
            $presenter->getViewModel(),
            $groupsPresenter->all('allGroups'),
            [
                'resourceId' => $doorId,
                'control' => 'detachDoorGroup',
                'resource' => 'door',
            ],
        ));
    }

    /**
     * @param string                                                          $doorId
     * @param \Source\UseCases\DoorGroup\AddDoorToGroup\AddDoorToGroupUseCase $doorGroup
     * @return \Illuminate\Http\RedirectResponse
     * @throws \Illuminate\Validation\ValidationException
     */
    public function addGroup(string $doorId, AddDoorToGroupUseCase $doorGroup): RedirectResponse
    {
        $this->validate($this->request, [
            'group_id' => 'required|string',
        ]);

        $presenter = new DoorGroupPresenter();

        $doorGroup->addDoorToGroup([$doorId], [$this->request->input('group_id')], $presenter);

        return redirect()->back()->with($presenter->getViewModel());
    }

    /**
     * @param string                                                                    $doorId
     * @param \Source\UseCases\DoorGroup\RemoveDoorFromGroup\RemoveDoorFromGroupUseCase $doorGroup
     * @return \Illuminate\Http\RedirectResponse
     * @throws \Illuminate\Validation\ValidationException
     */
    public function removeGroup(string $doorId, RemoveDoorFromGroupUseCase $doorGroup): RedirectResponse
    {
        $this->validate($this->request, [
            'group_id' => 'required|string',
        ]);

        $presenter = new RemoveDoorGroupPresenter();

        $doorGroup->removeDoorFromGroup([$doorId], [$this->request->input('group_id')], $presenter);

        return redirect()->back()->with($presenter->getViewModel());
    }

    /**
     * @param string                                                         $doorId
     * @param \Source\UseCases\DoorUser\UserDoorAccess\UserDoorAccessUseCase $doorUsers
     * @return \Illuminate\Contracts\View\View
     * @throws \Source\Exceptions\EntityNotFoundException
     */
    public function users(string $doorId, UserDoorAccessUseCase $doorUsers): View
    {
        $presenter = new UsersWebPresenter();

        $doorUsers->getDoorUserRelationships($doorId, $presenter);

        return view('layouts.admin.tableData', array_merge(
            $presenter->getViewModel(),
            [
                'route' => route('web.admin.doors.users', ['doorId' => $doorId]),
            ]
        ));
    }
}