Current File : /www/capitalgmcbuickregina_830/public/wp-content/plugins/ninja-forms-uploads/lib/Aws/Middleware.php
<?php
namespace NF_FU_LIB\Aws;
use NF_FU_LIB\Aws\Api\Service;
use NF_FU_LIB\Aws\Api\Validator;
use NF_FU_LIB\Aws\Credentials\CredentialsInterface;
use NF_FU_LIB\Aws\Exception\AwsException;
use NF_FU_LIB\GuzzleHttp\Promise;
use NF_FU_LIB\GuzzleHttp\Promise\Create;
use NF_FU_LIB\GuzzleHttp\Psr7;
use NF_FU_LIB\GuzzleHttp\Psr7\LazyOpenStream;
use NF_FU_LIB\GuzzleHttp\Psr7\MimeType;
use NF_FU_LIB\Psr\Http\Message\RequestInterface;
final class Middleware
{
/**
* Middleware used to allow a command parameter (e.g., "SourceFile") to
* be used to specify the source of data for an upload operation.
*
* @param Service $api
* @param string $bodyParameter
* @param string $sourceParameter
*
* @return callable
*/
public static function sourceFile(Service $api, $bodyParameter = 'Body', $sourceParameter = 'SourceFile')
{
return function (callable $handler) use($api, $bodyParameter, $sourceParameter) {
return function (CommandInterface $command, RequestInterface $request = null) use($handler, $api, $bodyParameter, $sourceParameter) {
$operation = $api->getOperation($command->getName());
$source = $command[$sourceParameter];
if ($source !== null && $operation->getInput()->hasMember($bodyParameter)) {
$command[$bodyParameter] = new LazyOpenStream($source, 'r');
unset($command[$sourceParameter]);
}
return $handler($command, $request);
};
};
}
/**
* Adds a middleware that uses client-side validation.
*
* @param Service $api API being accessed.
*
* @return callable
*/
public static function validation(Service $api, Validator $validator = null)
{
$validator = $validator ?: new Validator();
return function (callable $handler) use($api, $validator) {
return function (CommandInterface $command, RequestInterface $request = null) use($api, $validator, $handler) {
$operation = $api->getOperation($command->getName());
$validator->validate($command->getName(), $operation->getInput(), $command->toArray());
return $handler($command, $request);
};
};
}
/**
* Builds an HTTP request for a command.
*
* @param callable $serializer Function used to serialize a request for a
* command.
* @return callable
*/
public static function requestBuilder(callable $serializer)
{
return function (callable $handler) use($serializer) {
return function (CommandInterface $command) use($serializer, $handler) {
return $handler($command, $serializer($command));
};
};
}
/**
* Creates a middleware that signs requests for a command.
*
* @param callable $credProvider Credentials provider function that
* returns a promise that is resolved
* with a CredentialsInterface object.
* @param callable $signatureFunction Function that accepts a Command
* object and returns a
* SignatureInterface.
*
* @return callable
*/
public static function signer(callable $credProvider, callable $signatureFunction)
{
return function (callable $handler) use($signatureFunction, $credProvider) {
return function (CommandInterface $command, RequestInterface $request) use($handler, $signatureFunction, $credProvider) {
$signer = $signatureFunction($command);
return $credProvider()->then(function (CredentialsInterface $creds) use($handler, $command, $signer, $request) {
return $handler($command, $signer->signRequest($request, $creds));
});
};
};
}
/**
* Creates a middleware that invokes a callback at a given step.
*
* The tap callback accepts a CommandInterface and RequestInterface as
* arguments but is not expected to return a new value or proxy to
* downstream middleware. It's simply a way to "tap" into the handler chain
* to debug or get an intermediate value.
*
* @param callable $fn Tap function
*
* @return callable
*/
public static function tap(callable $fn)
{
return function (callable $handler) use($fn) {
return function (CommandInterface $command, RequestInterface $request = null) use($handler, $fn) {
$fn($command, $request);
return $handler($command, $request);
};
};
}
/**
* Middleware wrapper function that retries requests based on the boolean
* result of invoking the provided "decider" function.
*
* If no delay function is provided, a simple implementation of exponential
* backoff will be utilized.
*
* @param callable $decider Function that accepts the number of retries,
* a request, [result], and [exception] and
* returns true if the command is to be retried.
* @param callable $delay Function that accepts the number of retries and
* returns the number of milliseconds to delay.
* @param bool $stats Whether to collect statistics on retries and the
* associated delay.
*
* @return callable
*/
public static function retry(callable $decider = null, callable $delay = null, $stats = \false)
{
$decider = $decider ?: RetryMiddleware::createDefaultDecider();
$delay = $delay ?: [RetryMiddleware::class, 'exponentialDelay'];
return function (callable $handler) use($decider, $delay, $stats) {
return new RetryMiddleware($decider, $delay, $handler, $stats);
};
}
/**
* Middleware wrapper function that adds an invocation id header to
* requests, which is only applied after the build step.
*
* This is a uniquely generated UUID to identify initial and subsequent
* retries as part of a complete request lifecycle.
*
* @return callable
*/
public static function invocationId()
{
return function (callable $handler) {
return function (CommandInterface $command, RequestInterface $request) use($handler) {
return $handler($command, $request->withHeader('aws-sdk-invocation-id', \md5(\uniqid(\gethostname(), \true))));
};
};
}
/**
* Middleware wrapper function that adds a Content-Type header to requests.
* This is only done when the Content-Type has not already been set, and the
* request body's URI is available. It then checks the file extension of the
* URI to determine the mime-type.
*
* @param array $operations Operations that Content-Type should be added to.
*
* @return callable
*/
public static function contentType(array $operations)
{
return function (callable $handler) use($operations) {
return function (CommandInterface $command, RequestInterface $request = null) use($handler, $operations) {
if (!$request->hasHeader('Content-Type') && \in_array($command->getName(), $operations, \true) && ($uri = $request->getBody()->getMetadata('uri'))) {
$request = $request->withHeader('Content-Type', MimeType::fromFilename($uri) ?: 'application/octet-stream');
}
return $handler($command, $request);
};
};
}
/**
* Tracks command and request history using a history container.
*
* This is useful for testing.
*
* @param History $history History container to store entries.
*
* @return callable
*/
public static function history(History $history)
{
return function (callable $handler) use($history) {
return function (CommandInterface $command, RequestInterface $request = null) use($handler, $history) {
$ticket = $history->start($command, $request);
return $handler($command, $request)->then(function ($result) use($history, $ticket) {
$history->finish($ticket, $result);
return $result;
}, function ($reason) use($history, $ticket) {
$history->finish($ticket, $reason);
return Create::rejectionFor($reason);
});
};
};
}
/**
* Creates a middleware that applies a map function to requests as they
* pass through the middleware.
*
* @param callable $f Map function that accepts a RequestInterface and
* returns a RequestInterface.
*
* @return callable
*/
public static function mapRequest(callable $f)
{
return function (callable $handler) use($f) {
return function (CommandInterface $command, RequestInterface $request = null) use($handler, $f) {
return $handler($command, $f($request));
};
};
}
/**
* Creates a middleware that applies a map function to commands as they
* pass through the middleware.
*
* @param callable $f Map function that accepts a command and returns a
* command.
*
* @return callable
*/
public static function mapCommand(callable $f)
{
return function (callable $handler) use($f) {
return function (CommandInterface $command, RequestInterface $request = null) use($handler, $f) {
return $handler($f($command), $request);
};
};
}
/**
* Creates a middleware that applies a map function to results.
*
* @param callable $f Map function that accepts an Aws\ResultInterface and
* returns an Aws\ResultInterface.
*
* @return callable
*/
public static function mapResult(callable $f)
{
return function (callable $handler) use($f) {
return function (CommandInterface $command, RequestInterface $request = null) use($handler, $f) {
return $handler($command, $request)->then($f);
};
};
}
public static function timer()
{
return function (callable $handler) {
return function (CommandInterface $command, RequestInterface $request = null) use($handler) {
$start = \microtime(\true);
return $handler($command, $request)->then(function (ResultInterface $res) use($start) {
if (!isset($res['@metadata'])) {
$res['@metadata'] = [];
}
if (!isset($res['@metadata']['transferStats'])) {
$res['@metadata']['transferStats'] = [];
}
$res['@metadata']['transferStats']['total_time'] = \microtime(\true) - $start;
return $res;
}, function ($err) use($start) {
if ($err instanceof AwsException) {
$err->setTransferInfo(['total_time' => \microtime(\true) - $start] + $err->getTransferInfo());
}
return Create::rejectionFor($err);
});
};
};
}
}
Thank you for choosing Capital GMC Buick | Regina, your premier certified Buick and GMC dealership proudly serving drivers in Regina and the surrounding communities. Whether you’re searching for a brand-new Buick or GMC vehicle or a meticulously inspected pre-owned model, we have a diverse selection to match your needs and lifestyle.
Beyond our impressive inventory, we offer a seamless and stress-free financing experience through our well-connected finance centre, where our team of experts is dedicated to securing the best loan or lease options for you, quickly, transparently, and hassle-free.
But our commitment to you doesn’t stop at the sale. Our state-of-the-art service centre is staffed with skilled Buick and GMC technicians who use the latest equipment and genuine OEM parts to keep your vehicle running at its best. From routine maintenance to complex repairs, we’ve got you covered.
Experience top-tier customer service, quality vehicles, and expert care, all in one place. Visit Capital GMC Buick | Regina today or call us at 306-205-8072 with any questions. We’re here to help!
Have a question or need assistance? Fill out the form and we will reach out to you as soon as possible.
Schedule a Visit
Let us know when you are coming and how we can assist you. We can ensure someone will be on hand to help you out at the desired date and time.
Find a Career
Have a look at our list of available positions and apply online today to join our team!
Opportunities to Grow
The auto industry is constantly changing and we want to continue to grow. We offer growth, leadership & mentorship programs to allow our staff to grow with us.
Competitive Salary
We have a significant earning potential with incentive-based pay in most roles. We also offer an employee referral bonus with paid bonuses.
Health & Dental
We offer a comprehensive benefits package including extended health, dental, and vision care. We also include paramedical, life insurance, paid sick leave, short & long-term disability coverages.
Vacation
We value our employees and want everyone to take their vacation time. We offer a minimum of 2 weeks vacation each year.
Training & Development
We have many opportunities for paid education and training in-house as well as training from the Manufacturer.
$10,000 Cash Giveaway – Terms & Conditions
All October long, stop by Capital GMC Buick Cadillac, to enter for your chance to win $10,000 cash. No purchase is required, but entries must be made in-store.
The contest is open to residents of Saskatchewan who are 18+. Dealership employees and their households are not eligible. Entries will be accepted from October 1 to October 31, 2025. A random draw will take place on November 1, 2025.
The prize is one $10,000 award, paid by cheque, and must be accepted as awarded. Winner will be contacted by phone or email and must respond within 7 days or another entry may be drawn. Odds of winning depend on the number of entries received.By entering, you agree that Capital Automotive Group may use your name and photo for winner announcements. The contest is governed by the laws of Saskatchewan.
Members Only Bonus
