PHP object oriented programming

Question

I'm trying to learn OOP with PHP (I know it's hard because It's not an OOP language). I'm rewriting my procedural code to OOP.
Please provide any feedback on my code, naming and file/folder structure.

Structure:

\classes
  Procurement.php
  ProcurementDetails.php
\services
  DatabaseService.php
  ProcurementService.php
  ProcurementsService.php
\public
  Index.php
\routes
  Procurements.php

classes\Procurement.php

<?php

class Procurement {
    public int $id;
    public null | array | string $group;
    public null | string $object_name;
    public null | string $procurement_type;
    public null | string | object $responsible_user;
    public null | string $announcement_time;
    public null | string $status;
    public null | string | object $creator;

    public function __construct()
    {
        if ($this->responsible_user) $this->responsible_user=json_decode($this->responsible_user);
        if ($this->group) $this->group=json_decode($this->group);
        if ($this->creator) $this->creator=json_decode($this->creator);
    }

    private function __set($name, $value) {}
};

classes\ProcurementDetails.php

<?php
require_once __DIR__ . '/Procurement.php';

class ProcurementDetails extends Procurement {
    public null | string $description;
    public null | int $sum;
    public null | string $procurement_method;
    public null | string | array $contact_person;

    public function __construct()
    {
        if ($this->contact_person) $this->contact_person=json_decode($this->contact_person);
        parent::__construct();
    }
}

services\DatabaseService.php

<?php
interface IDatabaseService {
    /**
     *
     *
     * @return PDO
     */
    public function GetPDO();
}

class DatabaseService implements IDatabaseService { 
    /**
     * PDO object
     *
     * @var PDO
     */
    private $DB;
    private $host   = '';
    private $dbname = '';
    private $user   = '';
    private $pass   = '';
    
    /**
     * Creates the connection
     *
     * @return void
     */
    public function __construct () {
        $this->DB = new PDO("mysql:host={$this->host};dbname={$this->dbname};charset=utf8mb4",$this->user,$this->pass);
        $this->DB->setAttribute(PDO::ATTR_ERRMODE, PDO::ERRMODE_EXCEPTION);
        $this->DB->setAttribute(PDO::ATTR_EMULATE_PREPARES, false);
        $this->DB->setAttribute(PDO::ATTR_STRINGIFY_FETCHES, false);
    }
    
    public function getPDO() {
        return $this->DB;
    }

    /**
     * __destruct
     *
     * @return void
     */
    public function __destruct () {
        $this->DB=null;
    }

}

services\ProcurementsService.php

<?php
require_once __DIR__ . '/../classes/Procurement.php';
require_once __DIR__ . '/ProcurementService.php';

interface IProcurementsService {    
    /**
     * Returns all procurements from database
     * Procurement[]
     *
     * @return Procurement[]
     */
    public function GetAllProcurements();
    /**
     * GetById
     *
     * @param  int $id
     * @return IProcurementService
     */
    public function GetById(int $id);
}

class ProcurementsService implements IProcurementsService {

    private PDO $_db;
    
    /**
     * __construct
     *
     * @param  PDO $db
     * @return void
     */
    public function __construct(PDO $db)
    {
        $this->_db = $db;
    }
    
    /**
     * GetById
     *
     * @param  int $x
     * @return IProcurementService
     */
    public function GetById(int $id): IProcurementService {
        return new ProcurementService($id, $this->_db);
    }
    
    /**
     * Returns all procurements from database
     * Procurement[]
     *
     * @return Procurement[]
     */
    public function GetAllProcurements(): iterable {
        $stmt=$this->_db->query("SELECT ....");
        return $stmt->fetchAll(PDO::FETCH_CLASS, 'Procurement');
    }
}

classes\ProcurementService.php

<?php
require_once __DIR__ . '/../classes/ProcurementDetails.php';

interface IProcurementService {
    /**
     * Returns more info about the procurement
     *
     * @param  int $id
     * @return ProcurementDetails
     */
    public function GetDetails();
    public function GetFiles(); //Not implemented
    public function GetComments(); //Not implemented
}

class ProcurementService implements IProcurementService {
    private int $id;
    private PDO $_db;

    public function __construct(int $id, PDO $db)
    {
        $this->id = $id;
        $this->_db = $db;
    }

    /**
     * Returns more info about the procurement
     *
     * @param  int $id
     * @return ProcurementDetails
     */
    public function GetDetails(): ProcurementDetails
    {
        $stmt = $this->_db->prepare("SELECT with details....");
        $stmt->execute([$this->id]);
        return $stmt->fetchObject('ProcurementDetails');
    }

}

routes\Procurements.php

<?php
use Psr\Http\Message\ResponseInterface as Response;
use Psr\Http\Message\ServerRequestInterface as Request;

require_once __DIR__ . '/../services/DatabaseService.php';
require_once __DIR__ . '/../services/ProcurementsService.php';

$app->get('Procurements', function(Request $request, Response $response) {
    $DB=new DatabaseService();
    $ProcurementsService = new ProcurementsService($DB->getPDO());
    $response->getBody()->write(json_encode($ProcurementsService->GetById(100)->GetDetails()));
    return $response->withHeader('content-type','application/json')->withStatus(200);
});

I felt like I got off track with OOP, so I don't have much code. BTW! I am using PHPSLIM.

Answer 1

Firstly, PHP is 100% an 'OOP' language. It provides you with all the necessary functionality to conform to all of the OOP principles.

Secondly, you should definitely familiarise yourself with the PHP Standards Recommendations (PSR) as they will guide you in keeping everything inline with the standard conventions that PHP developers should follow when using the language.

Ok, with those nitpicking points out of the way, let's have a quick look at your code.

Utilisation of Interfaces

It's good to see you have the foresight to use interfaces, but your utilisation of them is a little off. One of the benefits of using interfaces is to ensure anything that implements it, conforms to the contract it has defined. This allows us to write a piece of code and swap out the implementation of the interface with something else, knowing full well that we won't need to change any of the utilising code.

Example:

We declare an interface for connecting to our database. As we may decide to implement different types of database connections, we need to selectively identify functions that will be needed for all database implementations. Note: I've kept it simple to ensure you grasp the concept, as opposed to what It's actually doing...

<?php

namespace App\EXAMPLE;

interface DatabaseInterface
{
    public function connect();

    public function disconnect();

    //Any other functions
}

This interface allows us to create different types of database connections and ensures the code we write to connect to the database, will remain untouched when swapping it out.

Here's what an implementation may look like utilising PDO.

<?php

namespace App\EXAMPLE;

class PDODatabase implements DatabaseInterface
{
    public function __construct(/* Any relevant params */)
    {
    }

    public function connect()
    {
        //Connect using PDO
    }

    public function disconnect()
    {
        //Disconnect
    }
}

Now in the area where we connect to the database, we can use the interface to define the type and then use any of the interface functions.

<?php

namespace App\EXAMPLE;

class DatabaseService
{
    private DatabaseInterface $database;
    
    public function __construct(DatabaseInterface $database)
    {
        $this->database = $database;
    }

    public function setup()
    {
        //Any setup that needs to be done
        $this->database->connect();
    }
}

When we define the type as an interface, it allows us to swap out the implementation with another. For example, say we wanted to change our PDODatabase to a MySQLi connection. We could easily write a MYSQLiDatabase.php class which implements the DatabaseInterface.php and pass that into our DatabaseService.php constructor. And because any class that is passed into the construct must conform to the interface, we know that there will be a connect and a disconnect function. This means we don't need to touch anything in the DatabaseService.php class because we have written code that requires an interface instead of a concrete implementation.

Avoid Ambiguity

I see that you're declaring your class variables with union types, which is PHP 8 and above, but just because you can doesn't mean you should.

public null | array | string $group;
public null | string $object_name;
public null | string $procurement_type;
public null | string | object $responsible_user;

Imagine coming back to this code in 6-12 months time. Trying to debug this would be a nightmare because PHP is very forgiving when it comes to types. I would personally recommend to only one type with the allowance of null if it is required.

public ?string $group;

The same can be said for functions that return something. PHP developers are renowned for returning many different types (mixed) from functions. My personal opinion on this is that it should be avoided because it just over complicates everything later down the track.

If you want to further your knowledge on building extendable code, I would highly recommend researching the SOLID Principles. There are a lot of great resources out there to help you along the way. Start off small and get a good understanding of everything before getting too adventurous and biting off more than you can chew.