NotesController.php

<?php
declare(strict_types=1);

/**
 * Copyright 2023, Cake Development Corporation (https://www.cakedc.com)
 *
 * Licensed under The MIT License
 * Redistributions of files must retain the above copyright notice.
 *
 * @copyright Copyright 2023, Cake Development Corporation (https://www.cakedc.com)
 * @license   MIT License (http://www.opensource.org/licenses/mit-license.php)
 */

namespace App\Controller;

use Cake\Controller\Controller;
use Cake\Datasource\Exception\InvalidPrimaryKeyException;
use Cake\Datasource\Exception\RecordNotFoundException;
use Cake\Log\Log;
use Cake\ORM\Exception\PersistenceFailedException;
use Cake\ORM\Exception\RolledbackTransactionException;
use Cake\ORM\TableRegistry;

/**
 * @property \App\Model\Table\NotesTable $Notes
 */
class NotesController extends Controller
{
    /**
     * Test TableEntityDynamicReturnTypeExtension to use correct entity type (App\Model\Entity\Node)
     * Should not have errors when accessig note property after NotesTable::newEntity, NotesTable::patchEntity
     * NotesTable::newEmptyEntity, NotesTable::saveOrFail, NotesTable::findOrCreate
     * NotesTable::newEntities, NotesTable::patchEntities, NotesTable::saveManyOrFail, NotesTable::deleteManyOrFail,
     * NotesTable::save
     *
     * @return void
     */
    public function add()
    {
        $entity = $this->fetchTable()->newEntity(['user_id' => 1]);
        $entity->note = 'My Note';
        Log::info('Accessing note after newEntity call' . $entity->note);

        $entityPatched = $this->fetchTable()->patchEntity($entity, ['user_id' => 10, 'note' => 'Other note']);
        Log::info('Accessing note after patchEntity call' . $entityPatched->note);

        $emptyEntity = $this->fetchTable()->newEmptyEntity();
        $emptyEntity->note = 'My Empty new entity test';
        Log::info('Accessing note after newEmptyEntity call' . $emptyEntity->note);

        $entitySaved = $this->fetchTable()->saveOrFail($entityPatched);
        Log::info('Accessing note after saveOrFail call' . $entitySaved->note);

        $findOrCreate = $this->fetchTable()->findOrCreate(['user_id' => 1, 'note' => 'My Note']);
        Log::info('Accessing note after findOrCreate call' . $findOrCreate->note);

        $entities = $this->fetchTable()->newEntities([['user_id' => 1], ['user_id' => 2]]);
        foreach ($entities as $newEntity) {
            $newEntity->note = 'My Empty new entities test';
            Log::info('Accessing note after newEntities call' . $newEntity->note);
        }

        $patchedEntities = $this->fetchTable()->patchEntities($entities, (array)$this->request->getData());
        foreach ($patchedEntities as $patchedEntity) {
            $patchedEntity->note = 'My patched entities test';
            Log::info('Accessing note after patchEntities call' . $patchedEntity->note);
        }
        $entitiesIterable = $this->fetchTable()->iterableItems();
        $patchedEntitiesIterable = $this->fetchTable()->patchEntities($entitiesIterable, (array)$this->request->getData());
        foreach ($patchedEntitiesIterable as $patchedEntityIt) {
            $patchedEntityIt->note = 'My patched entities test';
            Log::info('Accessing note after patchEntities call' . $patchedEntityIt->note);
        }
        $savedEntities = $this->fetchTable()->saveManyOrFail($patchedEntities);
        foreach ($savedEntities as $savedEntity) {
            $savedEntity->note = 'My patched saveManyOrFail test';
            Log::info('Accessing note after saveManyOrFail call' . $savedEntity->note);
        }

        $savedMany = $this->fetchTable()->saveMany($patchedEntities);
        if ($savedMany === false) {
            Log::info('Testing when saveMany return false, the return type must include the false option');
        } else {
            foreach ($savedMany as $saved) {
                $saved->note = 'My patched saveMany test';
                Log::info('Accessing note after saveMany call' . $saved->note);
            }
        }
        $deletedMany = $this->fetchTable()->deleteMany($patchedEntities);
        if ($deletedMany === false) {
            Log::info('Testing when saveMany return false, the return type must include the false option');
        } else {
            foreach ($deletedMany as $deleted) {
                $deleted->note = 'My patched deleteMany test';
                Log::info('Accessing note after deleteMany call' . $deleted->note);
            }
        }
        $deletedEntities = $this->fetchTable()->deleteManyOrFail($patchedEntities);
        foreach ($deletedEntities as $deletedEntity) {
            $deletedEntity->note = 'My patched deleteManyOrFail test';
            Log::info('Accessing note after deleteManyOrFail call' . $deletedEntity->note);
        }
        $entitySaved2 = $this->fetchTable()->save($entityPatched);
        if ($entitySaved2 === false) {
            Log::info('Testing when save return false, the return type must include the false option');
        } else {
            Log::info('Accessing note after save call' . $entitySaved2->note);
        }
        $entity = $this->fetchTable('Notes')->newEmptyEntity();
        $entity->note = 'Note using fetchTable(\'Notes\'';

        $entity2 = TableRegistry::getTableLocator()->get('Notes')->newEmptyEntity();
        $entity2->note = 'Note using fetchTable(\'Notes\')';
    }

    /**
     * Test ControllerFetchTableDynamicReturnTypeExtension with fetchTable using controller's className to extract
     * correct table class
     * Test TableEntityDynamicReturnTypeExtension with Notes::get to use correct entity type (App\Model\Entity\Node)
     *
     * @return void
     */
    public function addWarning()
    {
        $data = $this->fetchTable()->warning();
        $note = $this->fetchTable()->get(1)->note;
        $otherNote = $this->fetchTable()->get(2, contain: ['Users']);

        $data['note2'] = [
            'note' => $otherNote->note,
            'user_id' => $otherNote->user_id,
        ];
        $this->set(compact('data', 'note'));
    }

    /**
     * @return void
     */
    public function indexTestAssociation()
    {
        $note = $this->Notes->get(1);
        $user = $this->Notes->Users->get($note->user_id);
        $user->role = 'user';
        $userSaved = $this->Notes->Users->saveOrFail($user);
        $data = [
            'role' => $userSaved->role,
        ];

        $user = $this->Notes->Users->logLastLogin($userSaved);
        $data['lastLogin'] = $user->last_login;

        $user2 = $this->fetchTable()->Users->logLastLogin($userSaved);
        $data['lastLogin2'] = $user2->last_login;
        $this->set(compact('data'));

        //MyUsers table return User entity as specified in phpdoc tag @method
        $myUser = $this->fetchTable('MyUsers')->get(2);
        $sameRole = $myUser->role === 'user';
        $this->set(compact('sameRole'));
    }

    /**
     * @return void
     */
    public function listUsers()
    {
        //UsersTable::findByNamed exists it is not a magic method
        $userNamed = $this->Notes->Users->findByNamed('John Doe')->id;//Users is a BelongsTo association
        $this->set(compact('userNamed'));
        $userNamedMary = $this->fetchTable('Users')->findByNamed('Mary')->id;
        $this->set(compact('userNamedMary'));
        $myUserNamed = $this->Notes->MyUsers->findByNamed('John Doe')->id;//Users is a BelongsTo association
        $this->set(compact('myUserNamed'));

        //UsersTable::findByRole is a magic finder method
        $userList = $this->Notes->Users->findByRole('admin')->all()->toArray();
        $this->set(compact('userList'));
        $userListGuest = $this->fetchTable('Users')->findByRole('guest')->all()->toArray();
        $this->set(compact('userListGuest'));
        $myUsersList = $this->Notes->MyUsers->findByRole('admin')->all()->toArray();
        $this->set(compact('myUsersList'));

        //UsersTable::findAllByFoo exists it is not a magic method
        $users = $this->Notes->Users->findAllByFoo(100) / 20;
        $myUsers = $this->Notes->MyUsers->findAllByFoo(100) / 30;
        $this->set(compact('users', 'myUsers'));
        //BelongsTo should match the correct Users table methods.
        $this->Notes->Users->blockOld();
    }

    /**
     * @return void
     */
    public function viewWithTryCatch()
    {
        try {
            $note = $this->Notes->get(1);
            $note->note = 'This is a test';
        } catch (RecordNotFoundException) {
        }

        $user = $this->Notes->NewMyUsers->get(1);
        try {
            $this->Notes->NewMyUsers->save($user);
        } catch (RolledbackTransactionException) {
        }
        try {
            $this->Notes->NewMyUsers->findOrCreate(['name' => 'This is a test']);
        } catch (PersistenceFailedException) {
        }
        try {
            $this->Notes->NewMyUsers->saveOrFail($user);
        } catch (PersistenceFailedException) {
        }

        try {
            $this->Notes->NewMyUsers->saveMany([$user]);
        } catch (PersistenceFailedException) {
        }

        try {
            $this->Notes->NewMyUsers->saveManyOrFail([$user]);
        } catch (PersistenceFailedException) {
        }

        try {
            $this->Notes->NewMyUsers->deleteManyOrFail([$user]);
        } catch (PersistenceFailedException) {
        }

        try {
            $user = $this->Notes->get(1);
            $user->note = 'This is a test';
        } catch (InvalidPrimaryKeyException) {
        }

        try {
            $user = $this->Notes->Users->get(1);
            $user->name = 'user1';
        } catch (RecordNotFoundException) {
            //TableMethodThrowTypeExtension avoids dead catch
        }
        try {
            $user = $this->Notes->MyUsers->get(2);
            $user->name = 'user2';
        } catch (RecordNotFoundException) {
            //TableMethodThrowTypeExtension avoids dead catch
        }
        try {
            $user = $this->Notes->NewMyUsers->get(3);
            $user->name = 'user3';
        } catch (RecordNotFoundException) {
            //TableMethodThrowTypeExtension avoids dead catch
        }
    }
}