Как создать php файл отправки формы

Будни автоматизации или «мне нужна программка для 3D упаковки» Промо

Автоматизация отечественных предприятий, которой приходиться заниматься, это нужная и высокооплачиваемая, но довольно нервная работа. Выручает юмор. Например, при общении с требовательным клиентом можно вспомнить анекдот: «Держась руками за стену, на ногах еле стоит мужик. К нему пристает ребенок: «Ну, папа, пожалуйста, сделай мне кораблик!», папа отвечает: «Ага! — Сейчас все брошу и пойду делать тебе кораблик!». Про один такой сделанный для клиента «кораблик» и хочется рассказать. Надеюсь, совместное погружение в теплое ламповое (то есть клиентоориентированное) программирование доставит Вам положительные эмоции, да и задача попалась интересная. Поплыли?

Использование отчета как печатной формы документа

Пользователь попросил создать новый отчёт, но чтобы была возможность его распечатать из документа (в таком случае отчёт должен формироваться по этому документу), плюс при печати из документа должен быть заголовок и подвал с подписями. Однако, вид у внешней обработки может быть либо «Дополнительный отчет», либо «Печатная форма» (может быть ещё «Отчет» — для документа, но это тоже «либо» и задача была использовать типовой механизм формирования печатных форм). Чтобы не делать, по сути, два одинаковых отчёта, напрашивается мысль создать отдельно отчёт и печатную форму, но печатная форма должна вызывать формирование отчёта. В данной публикации представлен один из способов такой реализации.

Подробнее об операторе delayWhen

Давайте рассмотрим диаграму что бы понять как работает оператор delayWhen:

каждое значение в input Errors Observable будет публиковаться с задержкой в output Observable
задержка при каждой публикации значения может быть разной и будет создано вполне гибким путем
для того что бы определить задержку, мы вызовем функцию переданную в delayWhen(называемую функцией выбора продолжительности) для каждого значение в input Errors Observable
эта функция опубликует Observable который будет определять когда закончится задержка для каждого значения
каждое из значений a-b-c имеет свой собственный Observable выбирающий продолжительность, который будет публиковать значение (оно может быть чем угодно) и потом завершится
когда каждый из этих duration selector Observables опубликует, тогда соответствующее значение a-b-c будет опубликовано в output of delayWhen
заметим что значение будет опубликовано после значения, это нормально
это потому что duration selector Observable (3я горизонтальная линия с верху) публикует значение после того как было опубликовано значение связанное с duration selector Observable , и это объясняет почему отображается раньше

Реализация стратегии отложненой попытки (Delayed Retry Strategy)

Давайте все объеденим вместе и посмотрим как мы можем последовательно повторить провальный HTTP-запрос через 2 секунды после того как они были получены:

Давайте разберемся в том что здесь происходит:

вспомним что функция переданная в retryWhen будет вызвана однажды
в ней возвращается Observable который будет публиковать значения когда нужно повторить основной поток
каждый раз в когда возникает ошибка, delayWhen создает duration selector Observable, вызовом функции timer
duration selector Observable опубликует значение 0 через 2 секунда после своего завершения
как только это произойдет delayWhen Observable опубликует с соответствующей задержкой переданную ошибку
только раз задержка сработает (2 секунды после получения ошибки), ошибка попадет в output в notification Observable
как только значение будет опубликовано в notification Observable, тогда и только тогда оператор retryWhen запустит повторную попытку

Почему не первые два варианта?

Правка ошибок вручную

Да, лучше сразу писать все правильно с самого начала, но как я уже сказал, мы все допускаем ошибки. Ниже приведу основные недостатки данного подхода:

— Рутина. Представьте, что вы правите ошибки оформления кода день за днем. Разве вам не хотелось бы заняться чем-то более интересным? Уверен, что хотелось бы!

— Трата времени. Прочитайте пункт выше.

— Отсутствие постоянства. Вы хотите исключить все ошибки оформления кода из вашего проекта, верно? Если же вы делаете проверку стиля вручную, время от времени, то все это со временем приведет к дополнительным комитам в Git, содержащим только исправления форматирования кода. Это будет выглядеть плохо:

— add feature 3
— code style fixes
— add feature 2
— add feature 1

Плохо, верно? Конечно вы можете исправить историю объединив комиты, но тогда они перестанут быть атомарными и потеряют свой основной смысл.

Еще один момент: это также усложнит code review и сделает его менее продуктивным. Вместо того, чтобы сфокусироваться на серьезных и важных частях кода из pull request’а, ревьювер будет отвлекаться на посторонний шум — правки по стилю кода.

Плагины для IDE

Данный подход не так плох как первый, но:

— Плагина для вашего IDE может и не быть.

— Вам понадобится настроить ваше IDE таким образом, чтобы оно запускало PHP CS fixer при каждом соханении файла. Только таким образом вы добьетесь постоянства. Если же ваше IDE такого не умеет, значит вам не повезло.

— В нашей команде я не хочу никого принуждать использовать какое-то одно IDE. Каждый должен иметь возможность выбора и использовать то IDE, которое ему наиболее удобно в работе, без каких-либо ограничений.

Именно поэтому мы должны решить проблему постоянного мониторинга и исправления ошибок оформления кода на самом низком уровне, который не зависит от IDE и подойдет всем.

Запуск инструментов в терминале

Если вам не повезло с IDE, тогда данный вариант скорее всего тот, с которым вам прийдется иметь дело. Тем не менее, он также имеет недостатки:

— Отсутствие постоянства. Снова, вы должны не забывать запускать PHP CS fixer вручную в терминале.

— Трата времени. Представьте себе следующую ситуацию: вы добавили несколько файлов в staging область в Git. Затем вы вспомнили, что еще не запускали исправление оформления кода. Вы запускаете его и исправленные версии ваших файлов появляются в working области. Вам снова необходимо делать git add.

Все может быть еще хуже: вы сделали комит и только потом вспомнили про стиль кода… Вам также необходимо постоянно указывать fixer’у пути только к модифицированным файлам, которые вы хотите добавить в комит. Это нужно для того, чтобы ускорить процесс. Нет смысла проверять все файлы в проекте, если изменения были сделаны лишь в нескольких из них.

Если вдруг сообщит

Крайне редко удается протестировать программу полностью до выпуска и в то-же
время лучше не показывать пользователю сообщения об ошибках ибо его реакция на
них непредсказуема. Лучше перенаправлять ошибки транслятора, которые произошли
непосредственно во время работы программы, в log файл ошибок. Включить это
перенаправление можно опцией log_errors в файле php.ini.

Полезно также поставить свой обработчик ошибок, если Вы хотите не только
заносить ошибки в Log файл но и добавить некоторую дополнительную логику их
обработки. Например, отправить письмо при сообщении транслятора или вывести
некоторое специальное сообщение для пользователя. Подробнее об этом написано в
статье Ловля ошибок в PHP, которую написал Антон Довгаль.

Конфигурация среды выполнения

Поведение функций ошибок зависит от параметров в PHP. ini.

Ошибки и параметры настройки ведения журнала:

Имя	По умолчанию	Описание	Изменчива
error_reporting	NULL	Задает уровень отчетов об ошибках (целочисленные или именованные константы)	PHP_INI_ALL
display_errors	«1»	Указывает, следует ли печатать ошибки на экране или они должны быть скрыты от пользователя.Примечание: Эта функция никогда не должна использоваться в производственных системах (только для поддержки разработки)	PHP_INI_ALL
display_startup_errors	«0»	Даже при дисплай_еррорс, ошибки, возникающие во время запуска PHP последовательность не отображаютсяПримечание: Настоятельно рекомендуется держать дисплай_стартуп_еррорс Off, за исключением отладки	PHP_INI_ALL
log_errors	«0»	Определяет, должны ли сообщения об ошибках сценария регистрироваться в журнале ошибок сервера или еррор_лог.Примечание: Настоятельно рекомендуется использовать журнал ошибок вместо отображения ошибок на производственных веб-узлах	PHP_INI_ALL
log_errors_max_len	«1024»	Задает максимальную длину лог_еррорс в байтах. Значение «0» можно использовать, чтобы не применять любую максимальную длину. Эта длина применяется к зарегистрированным ошибкам, отображаемым ошибкам, а также к $PHP _еррормсг (доступно с PHP 4,3)	PHP_INI_ALL
ignore_repeated_errors	«0»	Указывает, следует ли регистрировать повторяющиеся сообщения об ошибках. Если установлено значение «1», он не будет регистрировать ошибки с повторяющимися ошибками из того же файла на той же строке (доступно с PHP 4,3)	PHP_INI_ALL
ignore_repeated_source	«0»	Указывает, следует ли регистрировать повторяющиеся сообщения об ошибках. Если установлено значение «1», оно не будет регистрировать ошибки с повторяющимися ошибками из разных файлов или исходных строк (доступно с PHP 4,3)	PHP_INI_ALL
report_memleaks	«1»	Если установлено значение «1» (по умолчанию), этот параметр покажет отчет о утечках памяти, обнаруженных менеджером Zend Memory Manager (доступен с версии PHP 4,3)	PHP_INI_ALL
track_errors	«0»	Если установлено значение «1», Последнее сообщение об ошибке всегда будет присутствовать в переменной $PHP _еррормсг	PHP_INI_ALL
html_errors	«1»	Отключение тегов HTML в сообщениях об ошибках	PHP_INI_ALLPHP_INI_SYSTEM in PHP <= 4.2.3.
xmlrpc_errors	«0»	Отключает нормальный отчет об ошибках и форматирует ошибки как XML-RPC сообщение об ошибке (доступно с PHP 4,1)	PHP_INI_SYSTEM
xmlrpc_error_number	«0»	Используется как значение элемента XML-RPC фаулткоде (доступно с PHP 4,1)	PHP_INI_ALL
docref_root	«»	(доступно с PHP 4,3)	PHP_INI_ALL
docref_ext	«»	(доступно с PHP 4.3.2)	PHP_INI_ALL
error_prepend_string	NULL	Задает строку для вывода перед сообщением об ошибке	PHP_INI_ALL
error_append_string	NULL	Задает строку для вывода после сообщения об ошибке	PHP_INI_ALL
error_log	NULL	Указывает имя файла, в котором должны регистрироваться ошибки сценария. Файл должен быть доступен для записи пользователем веб-сервера. Если используется специальное значение syslog, ошибки отправляются в системный журнал, а не	PHP_INI_ALL

Использование логера

Теперь, когда наш класс реализует интерфейс, предложенный стандартом PSR-3, мы можем легко задействовать его в любом месте. Например, в файле index.php:

<?php
// index.php
 
// Автозагрузчик Composer
require_once 'vendor/autoload.php';
// Наш новый класс-логер
require_once 'src/FileLogger.php';
 
$logger = new FileLogger();
$logger->debug('Message from index.php');

Или в любом другом классе.

<?php
 
use Psr\Log\LoggerInterface;
 
class ExampleService
{
   /** @var LoggerInterface */
   private $logger;
 
   public function __construct(LoggerInterface $logger)
   {
       $this->logger = $logger;
   }
 
   public function doSomeAction() void
   {
       // выполняем какие-либо действия
       $this->logger->debug('Message from ExampleService');
   }
}

Обратите внимание: в качестве типа аргумента конструктора мы указываем не конечную реализацию (FileLogger), а именно интерфейс стандарта PSR-3. Это удобно, потому что позволяет легко заменять применяемый логер на любой другой, поддерживающий этот интерфейс

Что такое ошибка PHP?

Ошибка PHP — это структура данных, представляющая что-то, что пошло не так в вашем приложении. В PHP есть несколько конкретных способов вызова ошибок. Один из простых способов имитировать ошибку — использовать die()функцию:

Это завершит программу PHP и сообщит об ошибке. Когда программа завершается, это то, что мы называем фатальной ошибкой. Позже вы увидите, что мы можем контролировать, как именно обрабатывается ошибка, в случае, если нам нужно вызвать некоторую логику очистки или перенаправить сообщение об ошибке. Вы также можете смоделировать это с помощью trigger_error()функции:

По умолчанию это вызовет в системе некритическое уведомление. Вы можете переопределить уровень ошибки, если вам нужна более серьезная ошибка.

На самом деле в PHP есть две формы ошибок: стандартные обычные ошибки и исключения.

Исключения были введены в PHP 5. Они дают вам легче семантику, как try, throwи catch. Исключение легко создать. Это следует из большого успеха языков со статической типизацией, таких как C # и Java.

Перехват и выдача исключений, как правило, более упрощены, чем более традиционная обработка ошибок PHP. Вы также можете иметь более локализованную обработку ошибок, а не только глобальную обработку ошибок с помощью set_error_handler (). Вы можете окружить конкретную логику блоками try / catch, которые заботятся только о конкретных исключениях:

Что происходит когда произошла ошибка?

Однако если возникла ошибка, то логика catchError будет срабатывать. Оператор catchError принимает ошибку и передает ее в функцию обработки ошибки.

Ожидается что эта функция вернет Observable который будет заменой Observable потока который только что ошибся

Давайте вспомним что входящий поток с catchError завершился ошибкой, следуя Observable-контракту мы больше не можем использовать этот поток.

На этот Observable(созданный в catchError) подпишутся, и его значения будут использованы в дальнейшей обработке потока.

Стратегия поймал и заменил (Catch and Replace Strategy)

Давайте возьмем пример того как catchError может быть использован для предоставления(to provide) замещающего Observable который публикует значения при крахе (fallback values):

Давайте разберемся в реализации стратегии поймал и заменил:

мы передаем оператору catchError функцю, которая является функцией обработки ошибки
фунекция обработки ошибки не вызывается сразу и как правило она не вызывается
только когда произошла ошибка в входном(input) Observable для catchError, будет вызвана функция обработки ошибки
если ошибка произошла в входящем потоке(input stream), эта функция возвращает Observable созданый при помощи функции
функция создает Observable который публикует только одно значение () и после завершается
функция обработки ошибки возвращает восстановленный (recovery) Observable (), на который подпишется оператор catchError
затем значения восстановленного Observable публикуются как замещающие значения в output Observable возвращаемым catchError

в результате, Observable не вернет больше ошибки anymore! Ниже результат который мы получим в консоле:

HTTP response []HTTP request completed.

Как мы видим, функция обработки ошибки в больше не вызывается. Вместо этого происходит следующее:

публикуется пустой массив
затем Observable завершается

Как мы видим замещающий Observable был использован для предоставления(provide) значения по умолчанию () при fallback, для подписчиков , вопреки тому факту что исходный Observable завершился ошибкой.

Обратите внимание, что мы могли бы также добавить некоторую локальную обработку ошибок, прежде чем возвращать замену Observable!

И это охватывается стратегией поймал и замени, теперь давайте посмотрим как еще мы можем использовать catchError для передачи ошибки, вместо передачи значения по умолчанию (fallback values).

Стратегия поймать и вернуть (Catch and Rethrow Strategy)

Начнем с того что заменающий Observable предоставляемый catchError может сам иметь ошибку, как и другие Observable.

И если это случается, ошибка будет распространена(propagated) на подписчиков output Observable нашего catchError.

Такое поведение распространения ошибки дает нам механизм для передачи(rethrow) ошибки пойманной в catchError, после локальной обработки ошибки. Мы можем сделать это следующим путем:

Стандарт PSR-3. Уровни логирования

PSR — это свод рекомендаций для PHP-разработчиков. Он содержит советы по оформлению кода, некоторые интерфейсы и другие рекомендации. Один из его документов (PSR-3) посвящён реализации логера.

Знакомство с этими рекомендациями предлагаю начать с уровней логирования, которые в них предлагаются.

<?php
 
namespace Psr\Log;
 
class LogLevel
{
   const EMERGENCY = 'emergency';
   const ALERT     = 'alert';
   const CRITICAL  = 'critical';
   const ERROR     = 'error';
   const WARNING   = 'warning';
   const NOTICE    = 'notice';
   const INFO      = 'info';
   const DEBUG     = 'debug';
}

PSR-3 определяет 8 уровней сообщений. Если их использовать правильно, искать ошибки станет проще и получится оперативнее реагировать на инциденты. Давайте разберёмся, как выбрать уровень:

DEBUG — отладочная информация, подробно раскрывающая детали события;
INFO — любые интересные события. Например, когда пользователь авторизовался;
NOTICE — важные события в рамках ожидаемого поведения;
WARNING — исключительные ситуации, не являющиеся ошибками. Например, использование устаревшего метода, неправильный запрос в API;
ERROR — ошибки, которые следует отслеживать, но они не требуют срочного исправления;
CRITICAL — критическое состояние или событие. Например, недоступность компонента, неожиданное исключение (Exception);
ALERT — ошибка или событие, требующие срочных действий. Например, когда база данных недоступна;
EMERGENCY — ситуация, когда программа или система полностью выведены из строя.

Чтобы использовать эти уровни, достаточно добавлять их название к строке каждой записи журнала. Например:

2021-01-01 121035 website.INFO User has changed his password

На уровни ALERT и EMERGENCY часто ставят дополнительное информирование, например по SMS. По INFO можно легко восстановить последовательность действий пользователя, по DEBUG — узнать точные значения переменных, результат работы функции в определённом месте и прочее.

Отображать ошибки PHP через настройки в .htaccess

Включить или выключить отображение ошибок можно и с помощью файла .htaccess, расположенного в каталоге сайта.

.htaccess также имеет директивы для displaystartuperrors и display_errors.

Вы можете настроить displayerrors в .htaccess или в вашем файле PHP.ini. Однако многие хостинг-провайдеры не разрешают вам изменять ваш файл PHP.ini для включения displayerrors.

В файле .htaccess также можно включить настраиваемый журнал ошибок, если папка журнала или файл журнала доступны для записи. Файл журнала может быть относительным путем к месту расположения .htaccess или абсолютным путем, например .

Использование функции die()

При написании вашей программы PHP вы должны проверить все возможные условия ошибки перед тем, как идти вперед, и при необходимости предпринять соответствующие действия.

Попробуйте привести пример без файла / tmp / test.xt и с этим файлом.

<?php
   if(!file_exists ("/ tmp /test.txt")) {
     die("File not found");
   } else {
      $file = fopen("/ tmp / test.txt" , "r " );
        print "Opend file sucessfully";
   }
   // Test of the code here.
?>

Таким образом, вы можете написать эффективный код. Используя вышеприведенную технику, вы можете остановить свою программу всякий раз, когда она выдает ошибки и отображает более содержательные и удобные для пользователя сообщения.

Библиотека Monolog

Несмотря на всю простоту принципа ведения журналов, в этой области широкий простор для модификаций. Мы могли бы поддержать другие форматы записей, реализовать отправку SMS или элементарно дать возможность менять имя конечного файла логов.

Здорово, что всё это уже реализовано в большинстве библиотек. Одна из самых распространённых – monolog.

Среди весомых преимуществ этого пакета:

полная поддержка PSR-3;
поддержка разных принципов обработки логов в зависимости от уровня;
поддержка имён каналов (имена логеров);
очень широкая поддержка фреймворков.

Чтобы начать использовать этот прекрасный инструмент, установим его с помощью Composer.

composer req monolog/monolog

Как включить вывод ошибок через .htaccess

Файл .htaccess должен находиться в корневой директории сайта (например, «public_html»). Отредактировать его можно с помощью проводника, доступного в панели хостинга.

Включить отображение ошибок PHP и настроить фильтрацию их вывода можно двумя директивами: «display_errors» и «error_reporting». Первая отвечает за состояние режима показа ошибок («On» или «Off»), а вторая задаёт глубину отображения.

Показать ошибки PHP на экране можно с помощью следующего кода:

php_flag display_errors on
php_value error_reporting -1

После сохранения изменённого файла, следует обновить страницу.

Вывод в консоль при немедленном повторе (Immediate Retry)

Если мы сейчас выполним эту программу, в консоле мы увидим следующее:

Мы видим что HTTP-запрос вернул ошибку, но после повторной попытке вернул значение.

Теперь давайте посмотрим на задержку между двумя попытками при помощи вкладки network в chrome devtools:

Как мы видим второй запрос был вызван немедленно после запроса с ошибкой, как и предполагалось.

Стратегия повтора с задержкой (Delayed Retry Strategy)

Давайте теперь реализуем альтернативную стратегию восстановления после ошибок, где мы ждем некоторое время после получения ошибки перед новой попыткой.

Такая стратегия восстановления полезна при определенных ошибках таких как ошибка при запросе по причине высокой нагрузки на сервере.

В тех случаях когда ошибка прерывистая, мы можем просто повторить запрос после короткой задержкой, и во второй раз запрос может вернутся без проблем.

Функция создания timer Observable

Для реализации стратегии повтора с задержкой(Delayed Retry Strategy), нам понадобится создать Notification Observable который будет запущен спустя 2 секунда после каждой произошедшей ошибки.

Давайте тогда поробуем создать Notification Observable используя функцию создания таймера. Эта таймер-функция принимает 2 аргумента:

начальная задержка, до которой значения не могут быть опубликованы
интервал, если мы хотим переодический публиковать новые значения

Давайте взглянем на диаграмму для таймер-функции:

Как мы видим первое значение 0 будет опубликовано через 3 секунда и потом публикуется каждое новое событие с интервалом в 1 секунду.

Заметьте что второй аргумент является опциональным, если мы его пропустим наш Observable опубликует только 0 через 3 секунды и после завершится.

Этот Observable выглядит хорошим началом для возможности отложить наши попытки повторных попыток, поэтому давайте посмотрим, как мы можем объединить его с операторами retryWhen и delayWhen.

Оператор delayWhen

Важно иметь ввиду что оператор retryWhen — это функция которая определяет Notification Observable вызыватеся однажды. Таким образом у нас есть одна попытка поределить наш Notification Observable, который сигнализирует когда должна завершится повторная попытка

Таким образом у нас есть одна попытка поределить наш Notification Observable, который сигнализирует когда должна завершится повторная попытка.

Мы собираемся определить Notification Observable взяв Errors Observable и добавив его в оператор delayWhen

Представьте что в диаграме ниже, исходный Observable a-b-c является Errors Observable, который постоянно публикует hhtp-ошибки: