/var/www/southraleighbiblechurch.org/public_html/src/App/Repository/MinistryRepository.php
use Doctrine\ORM\EntityManagerInterface;
use Doctrine\ORM\EntityRepository;
use Doctrine\ORM\NoResultException;
use Ramsey\Uuid\UuidInterface;
final class MinistryRepository
{
/** @var EntityRepository */
private $repository;
public function __construct(EntityManagerInterface $em)
{
$this->repository = $em->getRepository(Ministry::class);
}
public function find(UuidInterface $id) : Ministry
{
$ministry = $this->repository->find($id);
if ($ministry === null) {
throw new NoResultException();
}
return $ministry;
}
public function findFirst() : Ministry
{
$ministry = $this->repository->findOneBy([], ['createdAt' => Criteria::DESC]);
if ($ministry === null) {
throw new NoResultException();
}
return $ministry;
}
public function findForAdmin() : array
{
return $this->repository->findBy([], ['updatedAt' => Criteria::DESC]);
}
/** @return Ministry[] */
public function findAll() : array
/var/www/southraleighbiblechurch.org/public_html/src/App/Handler/MinistriesHandler.php
use Psr\Http\Server\RequestHandlerInterface;
use Ramsey\Uuid\Uuid;
use Laminas\Diactoros\Response\HtmlResponse;
use Mezzio\Template\TemplateRendererInterface;
class MinistriesHandler implements RequestHandlerInterface
{
private $renderer;
private $repository;
public function __construct(TemplateRendererInterface $renderer, MinistryRepository $repository)
{
$this->renderer = $renderer;
$this->repository = $repository;
}
public function handle(ServerRequestInterface $request) : ResponseInterface
{
$id = $request->getAttribute('id');
$ministry = $id !== null ? $this->repository->find(Uuid::fromString($id)) : $this->repository->findFirst();
return new HtmlResponse($this->renderer->render('app::ministries', [
'ministries' => $this->repository->findAll(),
'ministry' => $ministry,
]));
}
}
/var/www/southraleighbiblechurch.org/public_html/vendor/laminas/laminas-stratigility/src/Middleware/RequestHandlerMiddleware.php
public function __construct(RequestHandlerInterface $handler)
{
$this->handler = $handler;
}
/**
* Proxies to decorated handler to handle the request.
*/
public function handle(ServerRequestInterface $request) : ResponseInterface
{
return $this->handler->handle($request);
}
/**
* Proxies to decorated handler to handle the request.
*/
public function process(ServerRequestInterface $request, RequestHandlerInterface $handler) : ResponseInterface
{
return $this->handler->handle($request);
}
}
/var/www/southraleighbiblechurch.org/public_html/vendor/mezzio/mezzio/src/Middleware/LazyLoadingMiddleware.php
* @var string
*/
private $middlewareName;
public function __construct(
MiddlewareContainer $container,
string $middlewareName
) {
$this->container = $container;
$this->middlewareName = $middlewareName;
}
/**
* @throws InvalidMiddlewareException for invalid middleware types pulled
* from the container.
*/
public function process(ServerRequestInterface $request, RequestHandlerInterface $handler) : ResponseInterface
{
$middleware = $this->container->get($this->middlewareName);
return $middleware->process($request, $handler);
}
}
/var/www/southraleighbiblechurch.org/public_html/vendor/mezzio/mezzio-router/src/Route.php
?string $name = null
) {
$this->path = $path;
$this->middleware = $middleware;
$this->methods = is_array($methods) ? $this->validateHttpMethods($methods) : $methods;
if (! $name) {
$name = $this->methods === self::HTTP_METHOD_ANY
? $path
: $path . '^' . implode(self::HTTP_METHOD_SEPARATOR, $this->methods);
}
$this->name = $name;
}
/**
* Proxies to the middleware composed during instantiation.
*/
public function process(ServerRequestInterface $request, RequestHandlerInterface $handler): ResponseInterface
{
return $this->middleware->process($request, $handler);
}
public function getPath(): string
{
return $this->path;
}
/**
* Set the route name.
*/
public function setName(string $name): void
{
$this->name = $name;
}
public function getName(): string
{
return $this->name;
}
/var/www/southraleighbiblechurch.org/public_html/vendor/mezzio/mezzio-router/src/RouteResult.php
$result->allowedMethods = $methods;
return $result;
}
/**
* Process the result as middleware.
*
* If the result represents a failure, it passes handling to the handler.
*
* Otherwise, it processes the composed middleware using the provide request
* and handler.
*/
public function process(ServerRequestInterface $request, RequestHandlerInterface $handler): ResponseInterface
{
if ($this->isFailure()) {
return $handler->handle($request);
}
return $this->getMatchedRoute()->process($request, $handler);
}
/**
* Does the result represent successful routing?
*/
public function isSuccess(): bool
{
return $this->success;
}
/**
* Retrieve the route that resulted in the route match.
*
* @return false|null|Route false if representing a routing failure;
* null if not created via fromRoute(); Route instance otherwise.
*/
public function getMatchedRoute()
{
return $this->isFailure() ? false : $this->route;
}
/var/www/southraleighbiblechurch.org/public_html/vendor/mezzio/mezzio-router/src/Middleware/DispatchMiddleware.php
use Psr\Http\Server\RequestHandlerInterface;
/**
* Default dispatch middleware.
*
* Checks for a composed route result in the request. If none is provided,
* delegates request processing to the handler.
*
* Otherwise, it delegates processing to the route result.
*/
class DispatchMiddleware implements MiddlewareInterface
{
public function process(ServerRequestInterface $request, RequestHandlerInterface $handler): ResponseInterface
{
$routeResult = $request->getAttribute(RouteResult::class, false);
if (! $routeResult) {
return $handler->handle($request);
}
return $routeResult->process($request, $handler);
}
}
/var/www/southraleighbiblechurch.org/public_html/vendor/mezzio/mezzio/src/Middleware/LazyLoadingMiddleware.php
* @var string
*/
private $middlewareName;
public function __construct(
MiddlewareContainer $container,
string $middlewareName
) {
$this->container = $container;
$this->middlewareName = $middlewareName;
}
/**
* @throws InvalidMiddlewareException for invalid middleware types pulled
* from the container.
*/
public function process(ServerRequestInterface $request, RequestHandlerInterface $handler) : ResponseInterface
{
$middleware = $this->container->get($this->middlewareName);
return $middleware->process($request, $handler);
}
}
/var/www/southraleighbiblechurch.org/public_html/vendor/laminas/laminas-stratigility/src/Next.php
$this->queue = clone $queue;
$this->fallbackHandler = $fallbackHandler;
}
public function handle(ServerRequestInterface $request) : ResponseInterface
{
if ($this->queue === null) {
throw MiddlewarePipeNextHandlerAlreadyCalledException::create();
}
if ($this->queue->isEmpty()) {
$this->queue = null;
return $this->fallbackHandler->handle($request);
}
$middleware = $this->queue->dequeue();
$next = clone $this; // deep clone is not used intentionally
$this->queue = null; // mark queue as processed at this nesting level
return $middleware->process($request, $next);
}
}
/var/www/southraleighbiblechurch.org/public_html/src/App/Middleware/CatchNoResultMiddleware.php
TemplateRendererInterface $renderer,
ResponseFactoryInterface $responseFactory,
bool $debug
) {
$this->renderer = $renderer;
$this->responseFactory = $responseFactory;
$this->debug = $debug;
}
public function process(ServerRequestInterface $request, RequestHandlerInterface $handler) : ResponseInterface
{
if (!$this->debug) {
try {
return $handler->handle($request);
} catch (NoResultException $e) {
return $this->renderNotFoundResponse();
}
}
return $handler->handle($request);
}
}
/var/www/southraleighbiblechurch.org/public_html/vendor/mezzio/mezzio/src/Middleware/LazyLoadingMiddleware.php
* @var string
*/
private $middlewareName;
public function __construct(
MiddlewareContainer $container,
string $middlewareName
) {
$this->container = $container;
$this->middlewareName = $middlewareName;
}
/**
* @throws InvalidMiddlewareException for invalid middleware types pulled
* from the container.
*/
public function process(ServerRequestInterface $request, RequestHandlerInterface $handler) : ResponseInterface
{
$middleware = $this->container->get($this->middlewareName);
return $middleware->process($request, $handler);
}
}
/var/www/southraleighbiblechurch.org/public_html/vendor/laminas/laminas-stratigility/src/Next.php
$this->queue = clone $queue;
$this->fallbackHandler = $fallbackHandler;
}
public function handle(ServerRequestInterface $request) : ResponseInterface
{
if ($this->queue === null) {
throw MiddlewarePipeNextHandlerAlreadyCalledException::create();
}
if ($this->queue->isEmpty()) {
$this->queue = null;
return $this->fallbackHandler->handle($request);
}
$middleware = $this->queue->dequeue();
$next = clone $this; // deep clone is not used intentionally
$this->queue = null; // mark queue as processed at this nesting level
return $middleware->process($request, $next);
}
}
/var/www/southraleighbiblechurch.org/public_html/src/App/Middleware/UserMiddleware.php
use App\Helper\UserHelper;
use Psr\Http\Message\ResponseInterface;
use Psr\Http\Message\ServerRequestInterface;
use Psr\Http\Server\MiddlewareInterface;
use Psr\Http\Server\RequestHandlerInterface;
use Mezzio\Authentication\UserInterface;
class UserMiddleware implements MiddlewareInterface
{
private $helper;
public function __construct(UserHelper $helper)
{
$this->helper = $helper;
}
public function process(ServerRequestInterface $request, RequestHandlerInterface $handler) : ResponseInterface
{
$this->helper->setUserInterface($request->getAttribute(UserInterface::class));
return $handler->handle($request);
}
}
/var/www/southraleighbiblechurch.org/public_html/vendor/mezzio/mezzio/src/Middleware/LazyLoadingMiddleware.php
* @var string
*/
private $middlewareName;
public function __construct(
MiddlewareContainer $container,
string $middlewareName
) {
$this->container = $container;
$this->middlewareName = $middlewareName;
}
/**
* @throws InvalidMiddlewareException for invalid middleware types pulled
* from the container.
*/
public function process(ServerRequestInterface $request, RequestHandlerInterface $handler) : ResponseInterface
{
$middleware = $this->container->get($this->middlewareName);
return $middleware->process($request, $handler);
}
}
/var/www/southraleighbiblechurch.org/public_html/vendor/laminas/laminas-stratigility/src/Next.php
$this->queue = clone $queue;
$this->fallbackHandler = $fallbackHandler;
}
public function handle(ServerRequestInterface $request) : ResponseInterface
{
if ($this->queue === null) {
throw MiddlewarePipeNextHandlerAlreadyCalledException::create();
}
if ($this->queue->isEmpty()) {
$this->queue = null;
return $this->fallbackHandler->handle($request);
}
$middleware = $this->queue->dequeue();
$next = clone $this; // deep clone is not used intentionally
$this->queue = null; // mark queue as processed at this nesting level
return $middleware->process($request, $next);
}
}
/var/www/southraleighbiblechurch.org/public_html/src/Auth/Middleware/UserSessionMiddleware.php
use Mezzio\Authentication\UserInterface;
use Mezzio\Session\SessionInterface;
use Mezzio\Session\SessionMiddleware;
class UserSessionMiddleware implements MiddlewareInterface
{
private $service;
public function __construct(UserSessionService $service)
{
$this->service = $service;
}
public function process(ServerRequestInterface $request, RequestHandlerInterface $handler) : ResponseInterface
{
/** @var SessionInterface $session */
$session = $request->getAttribute(SessionMiddleware::SESSION_ATTRIBUTE);
$this->service->setUser($session->get(UserInterface::class));
return $handler->handle($request);
}
}
/var/www/southraleighbiblechurch.org/public_html/vendor/mezzio/mezzio/src/Middleware/LazyLoadingMiddleware.php
* @var string
*/
private $middlewareName;
public function __construct(
MiddlewareContainer $container,
string $middlewareName
) {
$this->container = $container;
$this->middlewareName = $middlewareName;
}
/**
* @throws InvalidMiddlewareException for invalid middleware types pulled
* from the container.
*/
public function process(ServerRequestInterface $request, RequestHandlerInterface $handler) : ResponseInterface
{
$middleware = $this->container->get($this->middlewareName);
return $middleware->process($request, $handler);
}
}
/var/www/southraleighbiblechurch.org/public_html/vendor/laminas/laminas-stratigility/src/Next.php
$this->queue = clone $queue;
$this->fallbackHandler = $fallbackHandler;
}
public function handle(ServerRequestInterface $request) : ResponseInterface
{
if ($this->queue === null) {
throw MiddlewarePipeNextHandlerAlreadyCalledException::create();
}
if ($this->queue->isEmpty()) {
$this->queue = null;
return $this->fallbackHandler->handle($request);
}
$middleware = $this->queue->dequeue();
$next = clone $this; // deep clone is not used intentionally
$this->queue = null; // mark queue as processed at this nesting level
return $middleware->process($request, $next);
}
}
/var/www/southraleighbiblechurch.org/public_html/vendor/mezzio/mezzio-helpers/src/UrlHelperMiddleware.php
private $helper;
public function __construct(UrlHelper $helper)
{
$this->helper = $helper;
}
/**
* Inject the UrlHelper instance with a RouteResult, if present as a request attribute.
* Injects the helper, and then dispatches the next middleware.
*/
public function process(ServerRequestInterface $request, RequestHandlerInterface $handler) : ResponseInterface
{
$result = $request->getAttribute(RouteResult::class, false);
if ($result instanceof RouteResult) {
$this->helper->setRouteResult($result);
}
return $handler->handle($request);
}
}
/var/www/southraleighbiblechurch.org/public_html/vendor/mezzio/mezzio/src/Middleware/LazyLoadingMiddleware.php
* @var string
*/
private $middlewareName;
public function __construct(
MiddlewareContainer $container,
string $middlewareName
) {
$this->container = $container;
$this->middlewareName = $middlewareName;
}
/**
* @throws InvalidMiddlewareException for invalid middleware types pulled
* from the container.
*/
public function process(ServerRequestInterface $request, RequestHandlerInterface $handler) : ResponseInterface
{
$middleware = $this->container->get($this->middlewareName);
return $middleware->process($request, $handler);
}
}
/var/www/southraleighbiblechurch.org/public_html/vendor/laminas/laminas-stratigility/src/Next.php
$this->queue = clone $queue;
$this->fallbackHandler = $fallbackHandler;
}
public function handle(ServerRequestInterface $request) : ResponseInterface
{
if ($this->queue === null) {
throw MiddlewarePipeNextHandlerAlreadyCalledException::create();
}
if ($this->queue->isEmpty()) {
$this->queue = null;
return $this->fallbackHandler->handle($request);
}
$middleware = $this->queue->dequeue();
$next = clone $this; // deep clone is not used intentionally
$this->queue = null; // mark queue as processed at this nesting level
return $middleware->process($request, $next);
}
}
/var/www/southraleighbiblechurch.org/public_html/src/Auth/Middleware/AuthorizationMiddleware.php
ResponseFactoryInterface $responseFactory,
LaminasRbac $zendRbac
) {
$this->renderer = $renderer;
$this->authorization = $authorization;
$this->responseFactory = $responseFactory;
$this->zendRbac = $zendRbac;
}
public function process(ServerRequestInterface $request, RequestHandlerInterface $handler) : ResponseInterface
{
$routeResult = $request->getAttribute(RouteResult::class);
// handle 404s
if ($routeResult->getMatchedRouteName() === false) {
return $handler->handle($request);
}
if ($this->zendRbac->isGranted('guest', $request)) {
return $handler->handle($request);
}
$user = $request->getAttribute(UserInterface::class, false);
if (!$user instanceof UserInterface) {
return $this->renderUnauthorizedResponse($request);
}
foreach ($user->getRoles() as $role) {
if ($this->authorization->isGranted($role, $request)) {
return $handler->handle($request);
}
}
return $this->renderUnauthorizedResponse($request);
}
}
/var/www/southraleighbiblechurch.org/public_html/vendor/mezzio/mezzio/src/Middleware/LazyLoadingMiddleware.php
* @var string
*/
private $middlewareName;
public function __construct(
MiddlewareContainer $container,
string $middlewareName
) {
$this->container = $container;
$this->middlewareName = $middlewareName;
}
/**
* @throws InvalidMiddlewareException for invalid middleware types pulled
* from the container.
*/
public function process(ServerRequestInterface $request, RequestHandlerInterface $handler) : ResponseInterface
{
$middleware = $this->container->get($this->middlewareName);
return $middleware->process($request, $handler);
}
}
/var/www/southraleighbiblechurch.org/public_html/vendor/laminas/laminas-stratigility/src/Next.php
$this->queue = clone $queue;
$this->fallbackHandler = $fallbackHandler;
}
public function handle(ServerRequestInterface $request) : ResponseInterface
{
if ($this->queue === null) {
throw MiddlewarePipeNextHandlerAlreadyCalledException::create();
}
if ($this->queue->isEmpty()) {
$this->queue = null;
return $this->fallbackHandler->handle($request);
}
$middleware = $this->queue->dequeue();
$next = clone $this; // deep clone is not used intentionally
$this->queue = null; // mark queue as processed at this nesting level
return $middleware->process($request, $next);
}
}
/var/www/southraleighbiblechurch.org/public_html/src/Auth/Middleware/AuthenticationMiddleware.php
if ($request->getRequestTarget() === $this->config['redirect']) {
$returnRequest = $request;
if (strtoupper($request->getMethod()) === 'POST') {
$returnRequest = $returnRequest->withAttribute('loginError', true);
}
return $handler->handle($returnRequest);
}
/** @var RouteResult $routeResult */
$routeResult = $request->getAttribute(RouteResult::class, false);
// handle 404s
if ($routeResult->getMatchedRouteName() === false) {
return $handler->handle($request);
}
if ($this->zendRbac->isGranted('guest', $request)) {
return $handler->handle($request);
}
$session->set('targetUrl', $request->getRequestTarget());
return $this->auth->unauthorizedResponse($request);
}
}
/var/www/southraleighbiblechurch.org/public_html/vendor/mezzio/mezzio/src/Middleware/LazyLoadingMiddleware.php
* @var string
*/
private $middlewareName;
public function __construct(
MiddlewareContainer $container,
string $middlewareName
) {
$this->container = $container;
$this->middlewareName = $middlewareName;
}
/**
* @throws InvalidMiddlewareException for invalid middleware types pulled
* from the container.
*/
public function process(ServerRequestInterface $request, RequestHandlerInterface $handler) : ResponseInterface
{
$middleware = $this->container->get($this->middlewareName);
return $middleware->process($request, $handler);
}
}
/var/www/southraleighbiblechurch.org/public_html/vendor/laminas/laminas-stratigility/src/Next.php
$this->queue = clone $queue;
$this->fallbackHandler = $fallbackHandler;
}
public function handle(ServerRequestInterface $request) : ResponseInterface
{
if ($this->queue === null) {
throw MiddlewarePipeNextHandlerAlreadyCalledException::create();
}
if ($this->queue->isEmpty()) {
$this->queue = null;
return $this->fallbackHandler->handle($request);
}
$middleware = $this->queue->dequeue();
$next = clone $this; // deep clone is not used intentionally
$this->queue = null; // mark queue as processed at this nesting level
return $middleware->process($request, $next);
}
}
/var/www/southraleighbiblechurch.org/public_html/vendor/mezzio/mezzio-router/src/Middleware/MethodNotAllowedMiddleware.php
* failure, it passes handling to the provided handler.
*/
class MethodNotAllowedMiddleware implements MiddlewareInterface
{
/** @var callable */
private $responseFactory;
public function __construct(callable $responseFactory)
{
// Factories is wrapped in a closure in order to enforce return type safety.
$this->responseFactory = function () use ($responseFactory): ResponseInterface {
return $responseFactory();
};
}
public function process(ServerRequestInterface $request, RequestHandlerInterface $handler): ResponseInterface
{
$routeResult = $request->getAttribute(RouteResult::class);
if (! $routeResult || ! $routeResult->isMethodFailure()) {
return $handler->handle($request);
}
return ($this->responseFactory)()
->withStatus(StatusCode::STATUS_METHOD_NOT_ALLOWED)
->withHeader('Allow', implode(',', $routeResult->getAllowedMethods()));
}
}
/var/www/southraleighbiblechurch.org/public_html/vendor/mezzio/mezzio/src/Middleware/LazyLoadingMiddleware.php
* @var string
*/
private $middlewareName;
public function __construct(
MiddlewareContainer $container,
string $middlewareName
) {
$this->container = $container;
$this->middlewareName = $middlewareName;
}
/**
* @throws InvalidMiddlewareException for invalid middleware types pulled
* from the container.
*/
public function process(ServerRequestInterface $request, RequestHandlerInterface $handler) : ResponseInterface
{
$middleware = $this->container->get($this->middlewareName);
return $middleware->process($request, $handler);
}
}
/var/www/southraleighbiblechurch.org/public_html/vendor/laminas/laminas-stratigility/src/Next.php
$this->queue = clone $queue;
$this->fallbackHandler = $fallbackHandler;
}
public function handle(ServerRequestInterface $request) : ResponseInterface
{
if ($this->queue === null) {
throw MiddlewarePipeNextHandlerAlreadyCalledException::create();
}
if ($this->queue->isEmpty()) {
$this->queue = null;
return $this->fallbackHandler->handle($request);
}
$middleware = $this->queue->dequeue();
$next = clone $this; // deep clone is not used intentionally
$this->queue = null; // mark queue as processed at this nesting level
return $middleware->process($request, $next);
}
}
/var/www/southraleighbiblechurch.org/public_html/vendor/mezzio/mezzio-router/src/Middleware/ImplicitOptionsMiddleware.php
/**
* @param callable $responseFactory A factory capable of returning an
* empty ResponseInterface instance to return for implicit OPTIONS
* requests.
*/
public function __construct(callable $responseFactory)
{
// Factories is wrapped in a closure in order to enforce return type safety.
$this->responseFactory = function () use ($responseFactory): ResponseInterface {
return $responseFactory();
};
}
/**
* Handle an implicit OPTIONS request.
*/
public function process(ServerRequestInterface $request, RequestHandlerInterface $handler): ResponseInterface
{
if ($request->getMethod() !== RequestMethod::METHOD_OPTIONS) {
return $handler->handle($request);
}
$result = $request->getAttribute(RouteResult::class);
if (! $result) {
return $handler->handle($request);
}
if ($result->isFailure() && ! $result->isMethodFailure()) {
return $handler->handle($request);
}
if ($result->getMatchedRoute()) {
return $handler->handle($request);
}
$allowedMethods = $result->getAllowedMethods();
return ($this->responseFactory)()->withHeader('Allow', implode(',', $allowedMethods));
}
}
/var/www/southraleighbiblechurch.org/public_html/vendor/mezzio/mezzio/src/Middleware/LazyLoadingMiddleware.php
* @var string
*/
private $middlewareName;
public function __construct(
MiddlewareContainer $container,
string $middlewareName
) {
$this->container = $container;
$this->middlewareName = $middlewareName;
}
/**
* @throws InvalidMiddlewareException for invalid middleware types pulled
* from the container.
*/
public function process(ServerRequestInterface $request, RequestHandlerInterface $handler) : ResponseInterface
{
$middleware = $this->container->get($this->middlewareName);
return $middleware->process($request, $handler);
}
}
/var/www/southraleighbiblechurch.org/public_html/vendor/laminas/laminas-stratigility/src/Next.php
$this->queue = clone $queue;
$this->fallbackHandler = $fallbackHandler;
}
public function handle(ServerRequestInterface $request) : ResponseInterface
{
if ($this->queue === null) {
throw MiddlewarePipeNextHandlerAlreadyCalledException::create();
}
if ($this->queue->isEmpty()) {
$this->queue = null;
return $this->fallbackHandler->handle($request);
}
$middleware = $this->queue->dequeue();
$next = clone $this; // deep clone is not used intentionally
$this->queue = null; // mark queue as processed at this nesting level
return $middleware->process($request, $next);
}
}
/var/www/southraleighbiblechurch.org/public_html/vendor/mezzio/mezzio-router/src/Middleware/ImplicitHeadMiddleware.php
{
$this->router = $router;
// Factory is wrapped in closur in order to enforce return type safety.
$this->streamFactory = function () use ($streamFactory): StreamInterface {
return $streamFactory();
};
}
/**
* Handle an implicit HEAD request.
*
* If the route allows GET requests, dispatches as a GET request and
* resets the response body to be empty; otherwise, creates a new empty
* response.
*/
public function process(ServerRequestInterface $request, RequestHandlerInterface $handler): ResponseInterface
{
if ($request->getMethod() !== RequestMethod::METHOD_HEAD) {
return $handler->handle($request);
}
$result = $request->getAttribute(RouteResult::class);
if (! $result) {
return $handler->handle($request);
}
if ($result->getMatchedRoute()) {
return $handler->handle($request);
}
$routeResult = $this->router->match($request->withMethod(RequestMethod::METHOD_GET));
if ($routeResult->isFailure()) {
return $handler->handle($request);
}
// Copy matched parameters like RouteMiddleware does
foreach ($routeResult->getMatchedParams() as $param => $value) {
$request = $request->withAttribute($param, $value);
}
/var/www/southraleighbiblechurch.org/public_html/vendor/mezzio/mezzio/src/Middleware/LazyLoadingMiddleware.php
* @var string
*/
private $middlewareName;
public function __construct(
MiddlewareContainer $container,
string $middlewareName
) {
$this->container = $container;
$this->middlewareName = $middlewareName;
}
/**
* @throws InvalidMiddlewareException for invalid middleware types pulled
* from the container.
*/
public function process(ServerRequestInterface $request, RequestHandlerInterface $handler) : ResponseInterface
{
$middleware = $this->container->get($this->middlewareName);
return $middleware->process($request, $handler);
}
}
/var/www/southraleighbiblechurch.org/public_html/vendor/laminas/laminas-stratigility/src/Next.php
$this->queue = clone $queue;
$this->fallbackHandler = $fallbackHandler;
}
public function handle(ServerRequestInterface $request) : ResponseInterface
{
if ($this->queue === null) {
throw MiddlewarePipeNextHandlerAlreadyCalledException::create();
}
if ($this->queue->isEmpty()) {
$this->queue = null;
return $this->fallbackHandler->handle($request);
}
$middleware = $this->queue->dequeue();
$next = clone $this; // deep clone is not used intentionally
$this->queue = null; // mark queue as processed at this nesting level
return $middleware->process($request, $next);
}
}
/var/www/southraleighbiblechurch.org/public_html/src/App/Middleware/PathMiddleware.php
use Psr\Http\Message\ResponseInterface;
use Psr\Http\Message\ServerRequestInterface;
use Psr\Http\Server\MiddlewareInterface;
use Psr\Http\Server\RequestHandlerInterface;
use Mezzio\Router\RouteResult;
class PathMiddleware implements MiddlewareInterface
{
private $helper;
public function __construct(PathHelper $helper)
{
$this->helper = $helper;
}
public function process(ServerRequestInterface $request, RequestHandlerInterface $handler) : ResponseInterface
{
$route = $request->getAttribute(RouteResult::class);
$this->helper->setRouteResult($route);
return $handler->handle($request);
}
}
/var/www/southraleighbiblechurch.org/public_html/vendor/mezzio/mezzio/src/Middleware/LazyLoadingMiddleware.php
* @var string
*/
private $middlewareName;
public function __construct(
MiddlewareContainer $container,
string $middlewareName
) {
$this->container = $container;
$this->middlewareName = $middlewareName;
}
/**
* @throws InvalidMiddlewareException for invalid middleware types pulled
* from the container.
*/
public function process(ServerRequestInterface $request, RequestHandlerInterface $handler) : ResponseInterface
{
$middleware = $this->container->get($this->middlewareName);
return $middleware->process($request, $handler);
}
}
/var/www/southraleighbiblechurch.org/public_html/vendor/laminas/laminas-stratigility/src/Next.php
$this->queue = clone $queue;
$this->fallbackHandler = $fallbackHandler;
}
public function handle(ServerRequestInterface $request) : ResponseInterface
{
if ($this->queue === null) {
throw MiddlewarePipeNextHandlerAlreadyCalledException::create();
}
if ($this->queue->isEmpty()) {
$this->queue = null;
return $this->fallbackHandler->handle($request);
}
$middleware = $this->queue->dequeue();
$next = clone $this; // deep clone is not used intentionally
$this->queue = null; // mark queue as processed at this nesting level
return $middleware->process($request, $next);
}
}
/var/www/southraleighbiblechurch.org/public_html/vendor/mezzio/mezzio-router/src/Middleware/RouteMiddleware.php
{
$this->router = $router;
}
public function process(ServerRequestInterface $request, RequestHandlerInterface $handler): ResponseInterface
{
$result = $this->router->match($request);
// Inject the actual route result, as well as individual matched parameters.
$request = $request
->withAttribute(RouteResult::class, $result)
->withAttribute(ZendExpressiveRouteResult::class, $result);
if ($result->isSuccess()) {
foreach ($result->getMatchedParams() as $param => $value) {
$request = $request->withAttribute($param, $value);
}
}
return $handler->handle($request);
}
}
/var/www/southraleighbiblechurch.org/public_html/vendor/mezzio/mezzio/src/Middleware/LazyLoadingMiddleware.php
* @var string
*/
private $middlewareName;
public function __construct(
MiddlewareContainer $container,
string $middlewareName
) {
$this->container = $container;
$this->middlewareName = $middlewareName;
}
/**
* @throws InvalidMiddlewareException for invalid middleware types pulled
* from the container.
*/
public function process(ServerRequestInterface $request, RequestHandlerInterface $handler) : ResponseInterface
{
$middleware = $this->container->get($this->middlewareName);
return $middleware->process($request, $handler);
}
}
/var/www/southraleighbiblechurch.org/public_html/vendor/laminas/laminas-stratigility/src/Next.php
$this->queue = clone $queue;
$this->fallbackHandler = $fallbackHandler;
}
public function handle(ServerRequestInterface $request) : ResponseInterface
{
if ($this->queue === null) {
throw MiddlewarePipeNextHandlerAlreadyCalledException::create();
}
if ($this->queue->isEmpty()) {
$this->queue = null;
return $this->fallbackHandler->handle($request);
}
$middleware = $this->queue->dequeue();
$next = clone $this; // deep clone is not used intentionally
$this->queue = null; // mark queue as processed at this nesting level
return $middleware->process($request, $next);
}
}
/var/www/southraleighbiblechurch.org/public_html/src/App/Middleware/FlashMessagesMiddleware.php
use Psr\Http\Server\RequestHandlerInterface;
use Mezzio\Flash\FlashMessageMiddleware;
use Mezzio\Flash\FlashMessagesInterface;
class FlashMessagesMiddleware implements MiddlewareInterface
{
private $helper;
public function __construct(FlashMessagesHelper $helper)
{
$this->helper = $helper;
}
public function process(ServerRequestInterface $request, RequestHandlerInterface $handler) : ResponseInterface
{
/** @var FlashMessagesInterface $flashMessages */
$flashMessages = $request->getAttribute(FlashMessageMiddleware::FLASH_ATTRIBUTE);
$this->helper->setFlashMessages($flashMessages);
return $handler->handle($request);
}
}
/var/www/southraleighbiblechurch.org/public_html/vendor/mezzio/mezzio/src/Middleware/LazyLoadingMiddleware.php
* @var string
*/
private $middlewareName;
public function __construct(
MiddlewareContainer $container,
string $middlewareName
) {
$this->container = $container;
$this->middlewareName = $middlewareName;
}
/**
* @throws InvalidMiddlewareException for invalid middleware types pulled
* from the container.
*/
public function process(ServerRequestInterface $request, RequestHandlerInterface $handler) : ResponseInterface
{
$middleware = $this->container->get($this->middlewareName);
return $middleware->process($request, $handler);
}
}
/var/www/southraleighbiblechurch.org/public_html/vendor/laminas/laminas-stratigility/src/Next.php
$this->queue = clone $queue;
$this->fallbackHandler = $fallbackHandler;
}
public function handle(ServerRequestInterface $request) : ResponseInterface
{
if ($this->queue === null) {
throw MiddlewarePipeNextHandlerAlreadyCalledException::create();
}
if ($this->queue->isEmpty()) {
$this->queue = null;
return $this->fallbackHandler->handle($request);
}
$middleware = $this->queue->dequeue();
$next = clone $this; // deep clone is not used intentionally
$this->queue = null; // mark queue as processed at this nesting level
return $middleware->process($request, $next);
}
}
/var/www/southraleighbiblechurch.org/public_html/src/App/Middleware/DeviceMiddleware.php
use App\Helper\DeviceHelper;
use Psr\Http\Message\ResponseInterface;
use Psr\Http\Message\ServerRequestInterface;
use Psr\Http\Server\MiddlewareInterface;
use Psr\Http\Server\RequestHandlerInterface;
class DeviceMiddleware implements MiddlewareInterface
{
private $helper;
public function __construct(DeviceHelper $helper)
{
$this->helper = $helper;
}
public function process(ServerRequestInterface $request, RequestHandlerInterface $handler) : ResponseInterface
{
$this->helper->setRequest($request);
return $handler->handle($request);
}
}
/var/www/southraleighbiblechurch.org/public_html/vendor/mezzio/mezzio/src/Middleware/LazyLoadingMiddleware.php
* @var string
*/
private $middlewareName;
public function __construct(
MiddlewareContainer $container,
string $middlewareName
) {
$this->container = $container;
$this->middlewareName = $middlewareName;
}
/**
* @throws InvalidMiddlewareException for invalid middleware types pulled
* from the container.
*/
public function process(ServerRequestInterface $request, RequestHandlerInterface $handler) : ResponseInterface
{
$middleware = $this->container->get($this->middlewareName);
return $middleware->process($request, $handler);
}
}
/var/www/southraleighbiblechurch.org/public_html/vendor/laminas/laminas-stratigility/src/Next.php
$this->queue = clone $queue;
$this->fallbackHandler = $fallbackHandler;
}
public function handle(ServerRequestInterface $request) : ResponseInterface
{
if ($this->queue === null) {
throw MiddlewarePipeNextHandlerAlreadyCalledException::create();
}
if ($this->queue->isEmpty()) {
$this->queue = null;
return $this->fallbackHandler->handle($request);
}
$middleware = $this->queue->dequeue();
$next = clone $this; // deep clone is not used intentionally
$this->queue = null; // mark queue as processed at this nesting level
return $middleware->process($request, $next);
}
}
/var/www/southraleighbiblechurch.org/public_html/vendor/mezzio/mezzio-helpers/src/ServerUrlMiddleware.php
{
/**
* @var ServerUrlHelper
*/
private $helper;
public function __construct(ServerUrlHelper $helper)
{
$this->helper = $helper;
}
/**
* Inject the ServerUrlHelper instance with the request URI.
* Injects the ServerUrlHelper with the incoming request URI, and then invoke
* the next middleware.
*/
public function process(ServerRequestInterface $request, RequestHandlerInterface $handler) : ResponseInterface
{
$this->helper->setUri($request->getUri());
return $handler->handle($request);
}
}
/var/www/southraleighbiblechurch.org/public_html/vendor/mezzio/mezzio/src/Middleware/LazyLoadingMiddleware.php
* @var string
*/
private $middlewareName;
public function __construct(
MiddlewareContainer $container,
string $middlewareName
) {
$this->container = $container;
$this->middlewareName = $middlewareName;
}
/**
* @throws InvalidMiddlewareException for invalid middleware types pulled
* from the container.
*/
public function process(ServerRequestInterface $request, RequestHandlerInterface $handler) : ResponseInterface
{
$middleware = $this->container->get($this->middlewareName);
return $middleware->process($request, $handler);
}
}
/var/www/southraleighbiblechurch.org/public_html/vendor/laminas/laminas-stratigility/src/Next.php
$this->queue = clone $queue;
$this->fallbackHandler = $fallbackHandler;
}
public function handle(ServerRequestInterface $request) : ResponseInterface
{
if ($this->queue === null) {
throw MiddlewarePipeNextHandlerAlreadyCalledException::create();
}
if ($this->queue->isEmpty()) {
$this->queue = null;
return $this->fallbackHandler->handle($request);
}
$middleware = $this->queue->dequeue();
$next = clone $this; // deep clone is not used intentionally
$this->queue = null; // mark queue as processed at this nesting level
return $middleware->process($request, $next);
}
}
/var/www/southraleighbiblechurch.org/public_html/vendor/mezzio/mezzio-flash/src/FlashMessageMiddleware.php
|| ! in_array(FlashMessagesInterface::class, class_implements($flashMessagesClass), true)
) {
throw Exception\InvalidFlashMessagesImplementationException::forClass($flashMessagesClass);
}
$this->flashMessageFactory = [$flashMessagesClass, 'createFromSession'];
$this->sessionKey = $sessionKey;
$this->attributeKey = $attributeKey;
}
public function process(ServerRequestInterface $request, RequestHandlerInterface $handler): ResponseInterface
{
$session = $request->getAttribute(SessionMiddleware::SESSION_ATTRIBUTE, false);
if (! $session instanceof SessionInterface) {
throw Exception\MissingSessionException::forMiddleware($this);
}
$flashMessages = ($this->flashMessageFactory)($session, $this->sessionKey);
return $handler->handle($request->withAttribute($this->attributeKey, $flashMessages));
}
}
/var/www/southraleighbiblechurch.org/public_html/vendor/mezzio/mezzio/src/Middleware/LazyLoadingMiddleware.php
* @var string
*/
private $middlewareName;
public function __construct(
MiddlewareContainer $container,
string $middlewareName
) {
$this->container = $container;
$this->middlewareName = $middlewareName;
}
/**
* @throws InvalidMiddlewareException for invalid middleware types pulled
* from the container.
*/
public function process(ServerRequestInterface $request, RequestHandlerInterface $handler) : ResponseInterface
{
$middleware = $this->container->get($this->middlewareName);
return $middleware->process($request, $handler);
}
}
/var/www/southraleighbiblechurch.org/public_html/vendor/laminas/laminas-stratigility/src/Next.php
$this->queue = clone $queue;
$this->fallbackHandler = $fallbackHandler;
}
public function handle(ServerRequestInterface $request) : ResponseInterface
{
if ($this->queue === null) {
throw MiddlewarePipeNextHandlerAlreadyCalledException::create();
}
if ($this->queue->isEmpty()) {
$this->queue = null;
return $this->fallbackHandler->handle($request);
}
$middleware = $this->queue->dequeue();
$next = clone $this; // deep clone is not used intentionally
$this->queue = null; // mark queue as processed at this nesting level
return $middleware->process($request, $next);
}
}
/var/www/southraleighbiblechurch.org/public_html/vendor/mezzio/mezzio-session/src/SessionMiddleware.php
class SessionMiddleware implements MiddlewareInterface
{
public const SESSION_ATTRIBUTE = 'session';
/** @var SessionPersistenceInterface */
private $persistence;
public function __construct(SessionPersistenceInterface $persistence)
{
$this->persistence = $persistence;
}
public function process(ServerRequestInterface $request, RequestHandlerInterface $handler): ResponseInterface
{
$session = new LazySession($this->persistence, $request);
$response = $handler->handle(
$request
->withAttribute(self::SESSION_ATTRIBUTE, $session)
->withAttribute(SessionInterface::class, $session)
);
return $this->persistence->persistSession($session, $response);
}
}
/var/www/southraleighbiblechurch.org/public_html/vendor/mezzio/mezzio/src/Middleware/LazyLoadingMiddleware.php
* @var string
*/
private $middlewareName;
public function __construct(
MiddlewareContainer $container,
string $middlewareName
) {
$this->container = $container;
$this->middlewareName = $middlewareName;
}
/**
* @throws InvalidMiddlewareException for invalid middleware types pulled
* from the container.
*/
public function process(ServerRequestInterface $request, RequestHandlerInterface $handler) : ResponseInterface
{
$middleware = $this->container->get($this->middlewareName);
return $middleware->process($request, $handler);
}
}
/var/www/southraleighbiblechurch.org/public_html/vendor/laminas/laminas-stratigility/src/Next.php
$this->queue = clone $queue;
$this->fallbackHandler = $fallbackHandler;
}
public function handle(ServerRequestInterface $request) : ResponseInterface
{
if ($this->queue === null) {
throw MiddlewarePipeNextHandlerAlreadyCalledException::create();
}
if ($this->queue->isEmpty()) {
$this->queue = null;
return $this->fallbackHandler->handle($request);
}
$middleware = $this->queue->dequeue();
$next = clone $this; // deep clone is not used intentionally
$this->queue = null; // mark queue as processed at this nesting level
return $middleware->process($request, $next);
}
}
/var/www/southraleighbiblechurch.org/public_html/vendor/laminas/laminas-stratigility/src/Middleware/ErrorHandler.php
/**
* Middleware to handle errors and exceptions in layers it wraps.
*
* Adds an error handler that will convert PHP errors to ErrorException
* instances.
*
* Internally, wraps the call to $next() in a try/catch block, catching
* all PHP Throwables.
*
* When an exception is caught, an appropriate error response is created
* and returned instead; otherwise, the response returned by $next is
* used.
*/
public function process(ServerRequestInterface $request, RequestHandlerInterface $handler) : ResponseInterface
{
set_error_handler($this->createErrorHandler());
try {
$response = $handler->handle($request);
} catch (Throwable $e) {
$response = $this->handleThrowable($e, $request);
}
restore_error_handler();
return $response;
}
/**
* Handles all throwables, generating and returning a response.
*
* Passes the error, request, and response prototype to createErrorResponse(),
* triggers all listeners with the same arguments (but using the response
* returned from createErrorResponse()), and then returns the response.
*/
private function handleThrowable(Throwable $e, ServerRequestInterface $request) : ResponseInterface
{
$generator = $this->responseGenerator;
$response = $generator($e, $request, ($this->responseFactory)());
/var/www/southraleighbiblechurch.org/public_html/vendor/mezzio/mezzio/src/Middleware/LazyLoadingMiddleware.php
* @var string
*/
private $middlewareName;
public function __construct(
MiddlewareContainer $container,
string $middlewareName
) {
$this->container = $container;
$this->middlewareName = $middlewareName;
}
/**
* @throws InvalidMiddlewareException for invalid middleware types pulled
* from the container.
*/
public function process(ServerRequestInterface $request, RequestHandlerInterface $handler) : ResponseInterface
{
$middleware = $this->container->get($this->middlewareName);
return $middleware->process($request, $handler);
}
}
/var/www/southraleighbiblechurch.org/public_html/vendor/laminas/laminas-stratigility/src/Next.php
$this->queue = clone $queue;
$this->fallbackHandler = $fallbackHandler;
}
public function handle(ServerRequestInterface $request) : ResponseInterface
{
if ($this->queue === null) {
throw MiddlewarePipeNextHandlerAlreadyCalledException::create();
}
if ($this->queue->isEmpty()) {
$this->queue = null;
return $this->fallbackHandler->handle($request);
}
$middleware = $this->queue->dequeue();
$next = clone $this; // deep clone is not used intentionally
$this->queue = null; // mark queue as processed at this nesting level
return $middleware->process($request, $next);
}
}
/var/www/southraleighbiblechurch.org/public_html/vendor/laminas/laminas-stratigility/src/MiddlewarePipe.php
* If the pipeline is empty at the time this method is invoked, it will
* raise an exception.
*
* @throws Exception\EmptyPipelineException if no middleware is present in
* the instance in order to process the request.
*/
public function handle(ServerRequestInterface $request) : ResponseInterface
{
return $this->process($request, new EmptyPipelineHandler(__CLASS__));
}
/**
* PSR-15 middleware invocation.
*
* Executes the internal pipeline, passing $handler as the "final
* handler" in cases when the pipeline exhausts itself.
*/
public function process(ServerRequestInterface $request, RequestHandlerInterface $handler) : ResponseInterface
{
return (new Next($this->pipeline, $handler))->handle($request);
}
/**
* Attach middleware to the pipeline.
*/
public function pipe(MiddlewareInterface $middleware) : void
{
$this->pipeline->enqueue($middleware);
}
}
/var/www/southraleighbiblechurch.org/public_html/vendor/laminas/laminas-stratigility/src/MiddlewarePipe.php
}
/**
* Handle an incoming request.
*
* Attempts to handle an incoming request by doing the following:
*
* - Cloning itself, to produce a request handler.
* - Dequeuing the first middleware in the cloned handler.
* - Processing the first middleware using the request and the cloned handler.
*
* If the pipeline is empty at the time this method is invoked, it will
* raise an exception.
*
* @throws Exception\EmptyPipelineException if no middleware is present in
* the instance in order to process the request.
*/
public function handle(ServerRequestInterface $request) : ResponseInterface
{
return $this->process($request, new EmptyPipelineHandler(__CLASS__));
}
/**
* PSR-15 middleware invocation.
*
* Executes the internal pipeline, passing $handler as the "final
* handler" in cases when the pipeline exhausts itself.
*/
public function process(ServerRequestInterface $request, RequestHandlerInterface $handler) : ResponseInterface
{
return (new Next($this->pipeline, $handler))->handle($request);
}
/**
* Attach middleware to the pipeline.
*/
public function pipe(MiddlewareInterface $middleware) : void
{
$this->pipeline->enqueue($middleware);
}
/var/www/southraleighbiblechurch.org/public_html/vendor/laminas/laminas-httphandlerrunner/src/RequestHandlerRunner.php
$this->serverRequestErrorResponseGenerator =
function (Throwable $exception) use ($serverRequestErrorResponseGenerator) : ResponseInterface {
return $serverRequestErrorResponseGenerator($exception);
};
}
/**
* Run the application
*/
public function run() : void
{
try {
$request = ($this->serverRequestFactory)();
} catch (Throwable $e) {
// Error in generating the request
$this->emitMarshalServerRequestException($e);
return;
}
$response = $this->handler->handle($request);
$this->emitter->emit($response);
}
private function emitMarshalServerRequestException(Throwable $exception) : void
{
$response = ($this->serverRequestErrorResponseGenerator)($exception);
$this->emitter->emit($response);
}
}
/var/www/southraleighbiblechurch.org/public_html/vendor/mezzio/mezzio/src/Application.php
return $this->pipeline->handle($request);
}
/**
* Proxies to composed pipeline to process.
* {@inheritDocs}
*/
public function process(ServerRequestInterface $request, RequestHandlerInterface $handler) : ResponseInterface
{
return $this->pipeline->process($request, $handler);
}
/**
* Run the application.
*
* Proxies to the RequestHandlerRunner::run() method.
*/
public function run() : void
{
$this->runner->run();
}
/**
* Pipe middleware to the pipeline.
*
* If two arguments are present, they are passed to pipe(), after first
* passing the second argument to the factory's prepare() method.
*
* If only one argument is presented, it is passed to the factory prepare()
* method.
*
* The resulting middleware, in both cases, is piped to the pipeline.
*
* @param string|array|callable|MiddlewareInterface|RequestHandlerInterface $middlewareOrPath
* Either the middleware to pipe, or the path to segregate the $middleware
* by, via a PathMiddlewareDecorator.
* @param null|string|array|callable|MiddlewareInterface|RequestHandlerInterface $middleware
* If present, middleware or request handler to segregate by the path
* specified in $middlewareOrPath.
*/
/var/www/southraleighbiblechurch.org/public_html/public/index.php
$password = 'Heb1116God';
$pdo = new PDO($dsn, $user, $password);
$stmt = $pdo->query('SELECT * FROM `Ministry`');
var_dump($stmt->fetchAll(PDO::FETCH_ASSOC));
exit;*/
/** @var \Psr\Container\ContainerInterface $container */
$container = require 'config/container.php';
/** @var \Mezzio\Application $app */
$app = $container->get(\Mezzio\Application::class);
$factory = $container->get(\Mezzio\MiddlewareFactory::class);
// Execute programmatic/declarative middleware pipeline and routing
// configuration statements
(require 'config/pipeline.php')($app, $factory, $container);
(require 'config/routes.php')($app, $factory, $container);
$app->run();
})();
/var/www/southraleighbiblechurch.org/public_html/public/index.php
$pdo = new PDO($dsn, $user, $password);
$stmt = $pdo->query('SELECT * FROM `Ministry`');
var_dump($stmt->fetchAll(PDO::FETCH_ASSOC));
exit;*/
/** @var \Psr\Container\ContainerInterface $container */
$container = require 'config/container.php';
/** @var \Mezzio\Application $app */
$app = $container->get(\Mezzio\Application::class);
$factory = $container->get(\Mezzio\MiddlewareFactory::class);
// Execute programmatic/declarative middleware pipeline and routing
// configuration statements
(require 'config/pipeline.php')($app, $factory, $container);
(require 'config/routes.php')($app, $factory, $container);
$app->run();
})();