Адаптер

<?php
/**
* Целевой класс объявляет интерфейс, с которым может работать клиентский код.
*/

class Target
{
    public function request(): string
    {
        return "Target: The default target's behavior.";
    }
}

/**
* Адаптируемый класс содержит некоторое полезное поведение, но его интерфейс
* несовместим с существующим клиентским кодом. Адаптируемый класс нуждается в
* некоторой доработке, прежде чем клиентский код сможет его использовать.
*/

class Adaptee
{
    public function specificRequest(): string
    {
        return ".eetpadA eht fo roivaheb laicepS";
    }
}

/**
* Адаптер делает интерфейс Адаптируемого класса совместимым с целевым
* интерфейсом.
*/

class Adapter extends Target
{
private $adaptee;

    public function __construct(Adaptee $adaptee)
    {
        $this->adaptee = $adaptee;
    }

    public function request(): string
    {
        return "Adapter: (TRANSLATED) " . strrev($this->adaptee->specificRequest());
    }
}

/**
* Клиентский код поддерживает все классы, использующие целевой интерфейс.
*/

function clientCode(Target $target)
{
    echo $target->request();
}

echo "Client: I can work just fine with the Target objects:\n";
$target = new Target();
clientCode($target);
echo "\n\n";

$adaptee = new Adaptee();
echo "Client: The Adaptee class has a weird interface. See, I don't understand it:\n";
echo "Adaptee: " . $adaptee->specificRequest();
echo "\n\n";

echo "Client: But I can work with it via the Adapter:\n";
$adapter = new Adapter($adaptee);
clientCode($adapter);

<?php
/**
* Целевой интерфейс предоставляет интерфейс, которому следуют классы вашего
* приложения.
*/

interface Notification
{
    public function send(string $title, string $message);
}

/**
* Вот пример существующего класса, который следует за целевым интерфейсом.
*
* Дело в том, что у большинства приложений нет чётко определённого интерфейса.
* В этом случае лучше было бы расширить Адаптер за счёт существующего класса
* приложения. Если это неудобно (например, SlackNotification не похож на
* подкласс EmailNotification), тогда первым шагом должно быть извлечение
* интерфейса.
*/

class EmailNotification implements Notification
{
    private $adminEmail;

    public function __construct(string $adminEmail)
    {
        $this->adminEmail = $adminEmail;
    }

    public function send(string $title, string $message): void
    {
        mail($this->adminEmail, $title, $message);
        echo "Sent email with title '$title' to '{$this->adminEmail}' that says '$message'.";
    }
}

/**
* Адаптируемый класс – некий полезный класс, несовместимый с целевым
* интерфейсом. Нельзя просто войти и изменить код класса так, чтобы следовать
* целевому интерфейсу, так как код может предоставляться сторонней библиотекой.
*/

class SlackApi
{
    private $login;
    private $apiKey;

    public function __construct(string $login, string $apiKey)
    {
        $this->login = $login;
        $this->apiKey = $apiKey;
    }

    public function logIn(): void
    {
        // Send authentication request to Slack web service.
        echo "Logged in to a slack account '{$this->login}'.\n";
    }

    public function sendMessage(string $chatId, string $message): void
    {
        // Send message post request to Slack web service.
        echo "Posted following message into the '$chatId' chat: '$message'.\n";
    }
}

/**
* Адаптер – класс, который связывает Целевой интерфейс и Адаптируемый класс.
* Это позволяет приложению использовать Slack API для отправки уведомлений.
*/

class SlackNotification implements Notification
{
    private $slack;
    private $chatId;

    public function __construct(SlackApi $slack, string $chatId)
    {
        $this->slack = $slack;
        $this->chatId = $chatId;
    }

    /**
    * Адаптер способен адаптировать интерфейсы и преобразовывать входные данные
    * в формат, необходимый Адаптируемому классу.
    */
    public function send(string $title, string $message): void
    {
        $slackMessage = "#" . $title . "# " . strip_tags($message);
        $this->slack->logIn();
        $this->slack->sendMessage($this->chatId, $slackMessage);
    }
}

/**
* Клиентский код работает с классами, которые следуют Целевому интерфейсу.
*/

function clientCode(Notification $notification)
{
// ...

    echo $notification->send("Website is down!",
    "<strong style='color:red;font-size: 50px;'>Alert!</strong> " .
    "Our website is not responding. Call admins and bring it up!");

    // ...
}

echo "Client code is designed correctly and works with email notifications:\n";
$notification = new EmailNotification("[email protected]");
clientCode($notification);
echo "\n\n";

echo "The same client code can work with other classes via adapter:\n";
$slackApi = new SlackApi("example.com", "XXXXXXXX");
$notification = new SlackNotification($slackApi, "Example.com Developers");
clientCode($notification);

<?php
// Существующий интерфейс, с которым работает клиентский код
interface PaymentProcessor {
    public function pay(float $amount, string $currency): string;
    public function refund(string $transactionId, float $amount): string;
}

// Существующая реализация, которая уже работает
class PayPalProcessor implements PaymentProcessor {
    public function pay(float $amount, string $currency): string {
        return "PayPal: charged {$amount} {$currency}";
    }

    public function refund(string $transactionId, float $amount): string {
        return "PayPal: refunded {$amount} for tx {$transactionId}";
    }
}

// Новый сторонний SDK с несовместимым API
class StripeSDK {
    public function createCharge(int $amountCents, string $currencyCode, array $metadata): array {
        return ['id' => 'ch_stripe_123', 'status' => 'succeeded', 'amount' => $amountCents];
    }

    public function createRefund(string $chargeId, int $amountCents): array {
        return ['id' => 're_stripe_456', 'status' => 'succeeded', 'amount' => $amountCents];
    }
}

// TODO: реализовать StripeAdapter implements PaymentProcessor,
// который оборачивает StripeSDK и адаптирует его к интерфейсу PaymentProcessor.
// Учтите: Stripe работает с центами (amount * 100), PaymentProcessor — с рублями/долларами.

// Клиентский код — не должен меняться
function checkout(PaymentProcessor $processor, float $amount, string $currency): void {
    echo $processor->pay($amount, $currency) . "\n";
}

checkout(new PayPalProcessor(), 1500.0, 'RUB');
// checkout(new StripeAdapter(new StripeSDK()), 1500.0, 'RUB'); // должно работать так же

<?php
// Интерфейс, которого ожидает приложение
interface Logger {
    public function info(string $message): void;
    public function warning(string $message): void;
    public function error(string $message, ?\Throwable $exception = null): void;
}

// Сторонняя библиотека с другим API (изменять нельзя)
class MonologLogger {
    public function __construct(private string $channel) {}

    public function addRecord(string $level, string $msg, array $context = []): void {
        $ts  = date('H:i:s');
        $ctx = $context ? ' ' . json_encode($context) : '';
        echo "[{$ts}] {$this->channel}.{$level}: {$msg}{$ctx}\n";
    }

    public function pushHandler(string $handlerName): void {
        echo "[Monolog] Handler '{$handlerName}' registered\n";
    }
}

// TODO: реализовать MonologAdapter implements Logger,
// который делегирует вызовы к MonologLogger::addRecord()
// с соответствующим уровнем: INFO, WARNING, ERROR.
// При вызове error() с exception — передавать её в context.

// Клиентский код
function processOrder(Logger $logger, int $orderId): void {
    $logger->info("Обработка заказа #{$orderId}");
    try {
        if ($orderId < 0) throw new InvalidArgumentException('ID не может быть отрицательным');
        $logger->info("Заказ #{$orderId} успешно обработан");
    } catch (InvalidArgumentException $e) {
        $logger->error('Ошибка обработки заказа', $e);
    }
}

// processOrder(new MonologAdapter(new MonologLogger('app')), 42);
// processOrder(new MonologAdapter(new MonologLogger('app')), -1);

<?php
// Интерфейс, с которым работает приложение
interface DataReader {
    public function readAll(): array;
    public function readById(int $recordId): ?array;
}

// Первый несовместимый источник — CSV-файл
class CsvFileReader {
    public function __construct(private string $filepath) {}

    public function open(): void { echo "[CSV] Открыт файл: {$this->filepath}\n"; }

    public function fetchRows(): array {
        return [
            ['id', 'name', 'price'],
            ['1', 'Книга', '350'],
            ['2', 'Ручка', '50'],
            ['3', 'Тетрадь', '80'],
        ];
    }

    public function close(): void { echo "[CSV] Файл закрыт: {$this->filepath}\n"; }
}

// Второй несовместимый источник — JSON API
class JsonApiClient {
    public function __construct(private string $baseUrl, private string $apiKey) {}

    public function getCollection(string $endpoint): array {
        return [
            'data' => [
                ['id' => 1, 'attributes' => ['name' => 'Книга',   'price' => 350]],
                ['id' => 2, 'attributes' => ['name' => 'Ручка',   'price' => 50]],
                ['id' => 3, 'attributes' => ['name' => 'Тетрадь', 'price' => 80]],
            ],
            'meta' => ['total' => 3],
        ];
    }

    public function getSingle(string $endpoint, int $recordId): ?array {
        foreach ($this->getCollection($endpoint)['data'] as $item) {
            if ($item['id'] === $recordId) return $item;
        }
        return null;
    }
}

// TODO: реализовать CsvDataAdapter implements DataReader
// и JsonApiAdapter implements DataReader

// Клиентский код
function printCatalog(DataReader $reader): void {
    foreach ($reader->readAll() as $item) {
        echo "  [{$item['id']}] {$item['name']} — {$item['price']} руб.\n";
    }
}

// printCatalog(new CsvDataAdapter(new CsvFileReader('products.csv')));
// printCatalog(new JsonApiAdapter(new JsonApiClient('https://api.shop.com', 'secret'), 'products'));

<?php
class Coordinates {
    public function __construct(public float $lat, public float $lng) {}
}

class Address {
    public function __construct(
        public string $country,
        public string $city,
        public string $street,
        public string $building,
    ) {}
}

// Интерфейс, которого ожидает приложение
interface GeoService {
    public function geocode(string $address): Coordinates;
    public function reverseGeocode(Coordinates $coords): Address;
    public function distanceKm(Coordinates $origin, Coordinates $destination): float;
}

// Первый внешний API (изменять нельзя)
class GoogleMapsAPI {
    public function findPlace(string $query): array {
        return ['geometry' => ['location' => ['lat' => 55.7558, 'lng' => 37.6173]]];
    }

    public function reverseGeocode(float $lat, float $lng): array {
        return ['results' => [['address_components' => [
            ['types' => ['country'],       'long_name' => 'Россия'],
            ['types' => ['locality'],      'long_name' => 'Москва'],
            ['types' => ['route'],         'long_name' => 'Тверская улица'],
            ['types' => ['street_number'], 'long_name' => '1'],
        ]]]];
    }

    public function distanceMatrix(array $origins, array $destinations): array {
        return ['rows' => [['elements' => [['distance' => ['value' => 5200]]]]]];
    }
}

// Второй внешний API (изменять нельзя)
class YandexMapsAPI {
    public function geocode(string $address): array {
        return ['response' => ['GeoObjectCollection' => ['featureMember' => [
            ['GeoObject' => ['Point' => ['pos' => '37.6173 55.7558']]]
        ]]]];
    }

    public function reverseGeocode(float $lon, float $lat): array {
        return ['response' => ['GeoObjectCollection' => ['featureMember' => [
            ['GeoObject' => ['metaDataProperty' => ['GeocoderMetaData' => [
                'AddressDetails' => ['Country' => [
                    'CountryName' => 'Россия',
                    'Locality' => ['LocalityName' => 'Москва',
                        'Thoroughfare' => ['ThoroughfareName' => 'Тверская',
                            'Premise' => ['PremiseNumber' => '1']]]
                ]]
            ]]]]
        ]]]];
    }

    public function route(string $fromPoint, string $toPoint): array {
        return ['route' => ['legs' => [['steps' => [['distance' => 5200]]]]]];
    }
}

// TODO: реализовать GoogleMapsAdapter implements GeoService
// и YandexMapsAdapter implements GeoService

// Клиентский код
function showLocationInfo(GeoService $service, string $address): void {
    $coords = $service->geocode($address);
    echo "Координаты: {$coords->lat}, {$coords->lng}\n";
    $addr = $service->reverseGeocode($coords);
    echo "Адрес: {$addr->city}, {$addr->street}, {$addr->building}\n";
}

// showLocationInfo(new GoogleMapsAdapter(new GoogleMapsAPI()), 'Тверская 1, Москва');
// showLocationInfo(new YandexMapsAdapter(new YandexMapsAPI()), 'Тверская 1, Москва');