public function actionDefault()
{
$params = $this->request->getParameters();
Nette\Utils\Validators::assertField($params, 'input', 'Symfony\\Component\\Console\\Input\\Input');
Nette\Utils\Validators::assertField($params, 'output', 'Symfony\\Component\\Console\\Output\\OutputInterface');
$this->sendResponse(new Kdyby\Console\CliResponse($this->console->run($params['input'], $params['output'])));
}
/**
* @throws AssertionException
*/
protected function validateConfigTypes(array $config)
{
Validators::assertField($config, 'isRecursive', 'bool');
Validators::assertField($config, 'trait', 'type');
Validators::assertField($config, 'userCallable', 'string');
Validators::assertField($config, 'userEntity', 'null|string');
}
/**
* @param array $config
* @param string $tokenStorageDefinition
* @param string|NULL $name
* @return ServiceDefinition
* @throws InvalidConfigException
*/
private function configureClient(array $config, $tokenStorageDefinition, $name = NULL)
{
$name = $name !== NULL ? ".{$name}" : '';
$builder = $this->getContainerBuilder();
$message = 'parameter % in LogisticsExtension configuration';
Validators::assertField($config, 'appId', 'string', $message);
Validators::assertField($config, 'secret', 'string', $message);
if (!$builder->parameters['debugMode']) {
Validators::assertField($config, 'apiBaseUrl', 'url', $message);
Validators::assertField($config, 'apiBaseUrl', 'pattern:https\\:\\/\\/.*', $message);
}
$consumerDefinition = $builder->addDefinition($this->prefix("consumer{$name}"))->setClass(Consumer::class, [$config['appId'], $config['secret']])->setAutowired(FALSE);
if (!array_key_exists('requestFactory', $config)) {
$requestFactoryDefinition = $builder->addDefinition($this->prefix("requestFactory{$name}"))->setClass(RequestFactory::class, [$config['apiBaseUrl']])->setAutowired(FALSE);
} else {
// touch reference to validate it
if (!$builder->getServiceName($requestFactoryDefinition = $config['requestFactory'])) {
throw new InvalidConfigException("Invalid reference to service implementing IRequestFactory given: {$config['requestFactory']}");
}
}
$connectorDefinition = $builder->addDefinition($this->prefix("connector{$name}"))->setClass(Connector::class, [$consumerDefinition, $tokenStorageDefinition, $requestFactoryDefinition])->setAutowired(FALSE);
$logisticsClientDefiniton = $builder->addDefinition($this->prefix("logisticsClient{$name}"))->setClass(LogisticsClient::class, [$connectorDefinition, $requestFactoryDefinition]);
if ($name !== '') {
$logisticsClientDefiniton->setAutowired(FALSE);
}
return $logisticsClientDefiniton;
}
public function loadConfiguration()
{
$builder = $this->getContainerBuilder();
$config = $this->getConfig($this->defaults);
$builder->addDefinition($this->prefix('expressionLanguage'))->setClass('Zycon42\\Security\\Authorization\\ExpressionLanguage')->setInject(FALSE);
Validators::assertField($config['decisionManager'], 'strategy', 'string');
Validators::assertField($config['decisionManager'], 'allowIfAllAbstain', 'bool');
Validators::assertField($config['decisionManager'], 'allowIfEqualGrantedDenied', 'bool');
$builder->addDefinition($this->prefix('decisionManager'))->setImplementType('Zycon42\\Security\\Authorization\\IAccessDecisionManager')->setClass('Zycon42\\Security\\Authorization\\AccessDecisionManager', $config['decisionManager'])->setInject(FALSE);
$builder->addDefinition($this->prefix('securityContext'))->setImplementType('Zycon42\\Security\\ISecurityContext')->setClass('Zycon42\\Security\\SecurityContext')->setInject(FALSE);
$builder->addDefinition($this->prefix('expressionEvaluator'))->setClass('Zycon42\\Security\\Application\\ExpressionEvaluator')->setInject(FALSE);
$builder->addDefinition($this->prefix('presenterRequirementsChecker'))->setClass('Zycon42\\Security\\Application\\PresenterRequirementsChecker')->setInject(FALSE);
$roleHierarchyUsed = false;
if ($config['roleHierarchy'] != FALSE) {
Validators::assert($config['roleHierarchy'], 'array');
$roleHierarchyUsed = true;
// When there's string in roleHierarchy value convert it to array
foreach ($config['roleHierarchy'] as $main => $roles) {
if (!is_array($roles)) {
$config['roleHierarchy'][$main] = [$roles];
}
}
$builder->addDefinition($this->prefix('roleHierarchy'))->setImplementType('Zycon42\\Security\\Role\\IRoleHierarchy')->setClass('Zycon42\\Security\\Role\\RoleHierarchy')->addSetup('setHierarchy', [$config['roleHierarchy']])->setInject(FALSE);
}
if ($config['voters'][self::VOTER_ROLE]) {
$class = $roleHierarchyUsed ? 'RoleHierarchyVoter' : 'RoleVoter';
$builder->addDefinition($this->prefix('voters.' . self::VOTER_ROLE))->setClass('Zycon42\\Security\\Authorization\\Voters\\' . $class)->addTag(self::TAG_VOTER)->setInject(FALSE);
}
if ($config['voters'][self::VOTER_EXPRESSION]) {
$builder->addDefinition($this->prefix('voters.' . self::VOTER_EXPRESSION))->setClass('Zycon42\\Security\\Authorization\\Voters\\ExpressionVoter')->addTag(self::TAG_VOTER)->setInject(FALSE);
}
if ($config['voters'][self::VOTER_AUTHENTICATED]) {
$builder->addDefinition($this->prefix('voters.' . self::VOTER_AUTHENTICATED))->setClass('Zycon42\\Security\\Authorization\\Voters\\AuthenticatedVoter')->addTag(self::TAG_VOTER)->setInject(FALSE);
}
}
public function loadConfiguration()
{
$builder = $this->getContainerBuilder();
$config = $this->getConfig($this->defaults);
Validators::assertField($config, 'merchantId', 'string');
Validators::assertField($config, 'shopName', 'string');
Validators::assertField($config, 'productionMode', 'bool');
Validators::assertField($config, 'returnMethod', 'string|pattern:(GET|POST)');
$envConfig = $config['productionMode'] ? $config['production'] : $config['sandbox'];
if (is_string($envConfig['privateKey'])) {
$envConfig['privateKey'] = ['path' => $envConfig['privateKey'], 'password' => NULL];
}
if (empty($envConfig['privateKey']['path']) || !file_exists($envConfig['privateKey']['path'])) {
throw new InvalidConfigException('Private key for not provided.');
}
$builder->addDefinition($this->prefix('config'))->setClass('Kdyby\\CsobPaymentGateway\\Configuration', [$config['merchantId'], $config['shopName']])->addSetup('setUrl', [$envConfig['url']])->addSetup('setReturnUrl', [$config['returnUrl']])->addSetup('setReturnMethod', [$config['returnMethod']]);
$builder->addDefinition($this->prefix('httpClient'))->setClass('Kdyby\\CsobPaymentGateway\\IHttpClient')->setFactory('Kdyby\\CsobPaymentGateway\\Http\\GuzzleClient')->setAutowired(FALSE);
$builder->addDefinition($this->prefix('signature'))->setClass('Kdyby\\CsobPaymentGateway\\Message\\Signature', [new Statement('Kdyby\\CsobPaymentGateway\\Certificate\\PrivateKey', [$envConfig['privateKey']['path'], $envConfig['privateKey']['password']]), new Statement('Kdyby\\CsobPaymentGateway\\Certificate\\PublicKey', [$envConfig['publicKey']])])->setAutowired(FALSE);
$client = $builder->addDefinition($this->prefix('client'))->setClass('Kdyby\\CsobPaymentGateway\\Client', [$this->prefix('@config'), $this->prefix('@signature'), $this->prefix('@httpClient')]);
if ($config['logging']) {
if (!is_bool($config['logging']) && class_exists('Kdyby\\Monolog\\Logger')) {
$client->addSetup('setLogger', [new Statement('@Kdyby\\Monolog\\Logger::channel', [$config['logging']])]);
} else {
$client->addSetup('setLogger');
// autowire
}
}
$builder->addDefinition($this->prefix('control'))->setImplement('Kdyby\\CsobPaygateNette\\UI\\ICsobControlFactory')->setArguments([$this->prefix('@client')]);
}
public function loadConfiguration()
{
$this->validateConfig($this->defaults);
Validators::assertField($this->config, 'firewalls', 'array');
foreach ($this->compiler->getExtensions('Arachne\\Security\\DI\\FirewallProviderInterface') as $extension) {
$firewalls = $extension->getFirewalls();
Validators::assert($firewalls, 'array');
$this->config['firewalls'] = array_merge($this->config['firewalls'], $firewalls);
}
foreach ($this->config['firewalls'] as $firewall => $class) {
if (!is_string($firewall)) {
$this->addFirewall($class);
} else {
$this->addFirewall($firewall, $class);
}
}
if ($extension = $this->getExtension('Arachne\\DIHelpers\\DI\\ResolversExtension', false)) {
$extension->add(self::TAG_FIREWALL, 'Arachne\\Security\\Authentication\\FirewallInterface');
$extension->add(self::TAG_AUTHORIZATOR, 'Arachne\\Security\\Authorization\\AuthorizatorInterface');
} elseif ($extension = $this->getExtension('Arachne\\DIHelpers\\DI\\DIHelpersExtension', false)) {
$extension->addResolver(self::TAG_FIREWALL, 'Arachne\\Security\\Authentication\\FirewallInterface');
$extension->addResolver(self::TAG_AUTHORIZATOR, 'Arachne\\Security\\Authorization\\AuthorizatorInterface');
} else {
throw new AssertionException('Cannot add resolvers because arachne/di-helpers is not properly installed.');
}
}
/**
* @param string $name
* @param array $config
* @return Nette\DI\ServiceDefinition
*/
protected function buildClient($name, $config)
{
$builder = $this->getContainerBuilder();
$defaultConfig = $this->getConfig($this->clientDefaults);
if ($parentName = Config\Helpers::takeParent($config)) {
Nette\Utils\Validators::assertField($this->configuredClients, $parentName, 'array', "parent configuration '%', are you sure it's defined?");
$defaultConfig = Config\Helpers::merge($this->configuredClients[$parentName], $defaultConfig);
}
$config = Config\Helpers::merge($config, $defaultConfig);
$config = array_intersect_key(self::fixClientConfig($config), $this->clientDefaults);
$client = $builder->addDefinition($clientName = $this->prefix(($name ? $name . '_' : '') . 'client'))->setClass('Kdyby\\Redis\\RedisClient', ['host' => $config['host'], 'port' => $config['port'], 'database' => $config['database'], 'timeout' => $config['timeout'], 'auth' => $config['auth'], 'persistent' => $config['persistent']]);
if (empty($builder->parameters[$this->name]['defaultClient'])) {
$builder->parameters[$this->name]['defaultClient'] = $clientName;
$this->configuredClients['default'] = $config;
$builder->addDefinition($this->prefix('default_client'))->setClass('Kdyby\\Redis\\RedisClient')->setFactory('@' . $clientName)->setAutowired(FALSE);
} else {
$client->setAutowired(FALSE);
}
$this->configuredClients[$name] = $config;
$client->addSetup('setupLockDuration', [$config['lockDuration'], $config['lockAcquireTimeout']]);
$client->addSetup('setConnectionAttempts', [$config['connectionAttempts']]);
$client->addTag('redis.client');
if (array_key_exists('debugger', $config) && $config['debugger']) {
$builder->addDefinition($panelName = $clientName . '.panel')->setClass('Kdyby\\Redis\\Diagnostics\\Panel')->setFactory('Kdyby\\Redis\\Diagnostics\\Panel::register')->addSetup('$renderPanel', [$config['debugger'] !== self::PANEL_COUNT_MODE])->addSetup('$name', [$name ?: 'default']);
$client->addSetup('setPanel', ['@' . $panelName]);
}
return $client;
}
/**
* @param $config
* @return void
*/
public function configValidation($config)
{
Validators::assertField($config, 'authenticators', 'array');
Validators::assertField($config, 'ips', 'array');
Validators::assertField($config, 'referers', 'array');
Validators::assertField($config, 'cors', 'array');
Validators::assertField($config, 'systemSalt', 'string');
}
private function setupCompileTemplatesCommand(ContainerBuilder $builder, array $config)
{
$config = $this->validateConfig($this->compileTemplatesDefaults, $config, 'compileTemplates');
Validators::assertField($config, 'source', 'string|array');
$builder->addDefinition($this->prefix('compileTemplates'))->setClass(CompileTemplatesCommand::class, [array_map(function ($directory) use($builder) {
Validators::assert($directory, 'string');
return Helpers::expand($directory, $builder->parameters);
}, (array) $config['source'])])->addTag(ConsoleExtension::TAG_COMMAND)->setAutowired(false);
}
private function getSection(array $data, $key, $file)
{
Validators::assertField($data, $key, 'array|null', "section '%' in file '{$file}'");
$item = $data[$key];
if ($parent = Helpers::takeParent($item)) {
$item = Helpers::merge($item, $this->getSection($data, $parent, $file));
}
return $item;
}
public function loadConfiguration()
{
$builder = $this->getContainerBuilder();
$config = $this->getConfig(array('enabled' => !$builder->expand('%debugMode%')));
Nette\Utils\Validators::assertField($config, 'enabled');
if ($builder->expand($config['enabled'])) {
$builder->addDefinition($this->prefix('listener'))->setClass('Mishak\\NewRelicLogger\\NewRelicProfilingListener')->addTag(Kdyby\Events\DI\EventsExtension::SUBSCRIBER_TAG);
}
}
/**
* @throws AssertionException
*/
private function validateConfigTypes(array $config)
{
Validators::assertField($config, 'isRecursive', 'bool');
Validators::assertField($config, 'currentLocaleCallable', NULL | 'array');
Validators::assertField($config, 'translatableTrait', 'type');
Validators::assertField($config, 'translationTrait', 'type');
Validators::assertField($config, 'translatableFetchMode', 'string');
Validators::assertField($config, 'translationFetchMode', 'string');
}
/**
* Creates service definitions according annotated services classes.
*/
public function loadConfiguration()
{
$this->conf = $this->getConfig($this->defaults);
Validators::assertField($this->conf, 'dirs', 'array');
Validators::assertField($this->conf, 'allowedAnnotations', 'array');
//Browse the directory and subdirectories and search services
foreach ($this->conf['dirs'] as $dir) {
$this->addServicesFromDir($dir);
}
}
public function loadConfiguration()
{
$config = $this->validateConfig($this->defaults);
$builder = $this->getContainerBuilder();
Validators::assertField($config, 'goId', 'string|number');
Validators::assertField($config, 'clientId', 'string|number');
Validators::assertField($config, 'clientSecret', 'string');
Validators::assertField($config, 'test', 'bool');
$builder->addDefinition($this->prefix('client'))->setClass(Client::class, [new Statement(Config::class, [$config['goId'], $config['clientId'], $config['clientSecret'], $config['test'] !== FALSE ? Config::TEST : Config::PROD])]);
}
public function loadConfiguration()
{
$this->defaults = Nette\Neon\Neon::decode(file_get_contents(__DIR__ . '/defaults.neon'))['hyperrow'];
$config = $this->getConfig($this->defaults);
Validators::assertField($config, 'nestedTransactions', 'bool');
$builder = $this->getContainerBuilder();
$builder->addDefinition($this->prefix('config'))->setClass(Config::class, [$config]);
$builder->addDefinition($this->prefix('factory'))->setClass(Factory::class, [$config['classes']['selection']['mapping'], $config['classes']['row']['mapping']]);
$builder->addDefinition($this->prefix('generator'))->setClass(Generator::class, [$config])->setAutowired(FALSE);
}
public function beforeCompile()
{
parent::beforeCompile();
$containerBuilder = $this->getContainerBuilder();
foreach ($containerBuilder->findByTag(static::TAG_CONTAINER_CONTROL_CONTROL) as $serviceName => $containerControlControlTags) {
Validators::assertField($containerControlControlTags, 'name', 'string');
Validators::assertField($containerControlControlTags, 'containerControl', 'string');
$containerControlService = $containerBuilder->getDefinition($this->prefix($containerControlControlTags['containerControl'] . 'ContainerControlFactory'));
$containerControlService->addSetup('?->registerControlFactory(?, ?)', ['@self', $containerControlControlTags['name'], '@' . $serviceName]);
}
}
/**
* @param array
* @throws AssertionException
* @throws \Exception
*/
private function validateConfigParameters($config)
{
Validators::assertField($config, 'dir', 'string');
Validators::assertField($config, 'table', 'string');
if (!is_dir($config['dir'])) {
throw new \Exception('Dir "' . $config['dir'] . '" not found! Create it.');
}
if (!is_writeable($config['dir'])) {
throw new \Exception('Dir "' . $config['dir'] . '" is not writeable.');
}
}
public function afterCompile(ClassType $class)
{
$config = $this->getConfig($this->defaults);
Validators::assertField($config, 'enabled', 'boolean');
if ($config['enabled']) {
Validators::assertField($config, 'slackUrl', 'string');
Validators::assertField($config, 'logUrl', 'string');
$init = $class->getMethod('initialize');
$init->addBody(Debugger::class . '::setLogger(new ' . SlackLogger::class . '(?, ?));', [$config['slackUrl'], $config['logUrl']]);
}
}
public function loadConfiguration()
{
$builder = $this->getContainerBuilder();
$config = $this->validateConfig($this->defaults);
$builder->addDefinition($this->prefix('entropyProvider'))->setClass(IEntropyProvider::class)->setFactory(OpenSslEntropyProvider::class);
Validators::assertField($config, 'appId', 'string');
Validators::assertField($config, 'attestDir', 'string|null');
$builder->addDefinition($this->prefix('config'))->setClass(Config::class, $config);
$builder->addDefinition($this->prefix('server'))->setClass(Server::class);
$builder->addDefinition($this->prefix('registrationRepository'))->setClass(IRegistrationRepository::class)->setFactory(CacheRegistrationRepository::class);
$builder->addDefinition($this->prefix('dialogFactory'))->setClass(DialogFactory::class);
}
/**
* @inheritdoc
*/
public function loadConfiguration()
{
$builder = $this->getContainerBuilder();
$config = $this->validateConfig($this->defaults);
Validators::assertField($config, 'encryptionKey', 'string');
Helpers::getEncryptionKey($config['encryptionKey']);
Validators::assertField($config, 'signingKey', 'string');
Helpers::getSigningKey($config['signingKey']);
Validators::assertField($config, 'bcryptCost', 'int');
Helpers::getBcryptCost($config['bcryptCost']);
$builder->addDefinition($this->prefix('passwords'))->setClass('Ark8\\Passwords\\Passwords', [new Statement('Ark8\\Passwords\\Context', [$config['encryptionKey'], $config['signingKey'], $config['bcryptCost']])]);
}
public function loadConfiguration()
{
// Cause we don't want merge arrays (annotations, interfaces, etc..)
$config = $this->getCustomConfig($this->defaults);
// Validate config
Validators::assertField($config, 'dirs', 'array');
Validators::assertField($config, 'annotations', 'array|null');
Validators::assertField($config, 'interfaces', 'array|null');
Validators::assertField($config, 'decorator', 'array');
// Expand config (cause %appDir% etc..)
$this->config = Helpers::expand($config, $this->getContainerBuilder()->parameters);
}
public function loadConfiguration()
{
$config = $this->validateConfig($this->defaults);
Validators::assertField($config, 'debugger', 'boolean');
Validators::assertField($config, 'genDir', 'string');
Validators::assertField($config, 'files', 'array');
$builder = $this->getContainerBuilder();
$wwwDir = $builder->parameters['wwwDir'];
$genDir = $config['genDir'];
if (!is_writable("{$wwwDir}/{$genDir}")) {
throw new Nette\IOException("Directory '{$wwwDir}/{$genDir}' is not writable.");
}
}
public function loadConfiguration()
{
$config = $this->getConfig($this->defaults);
Validators::assertField($config, self::FRAKKIN_KEY, 'array');
foreach ($this->compiler->getExtensions('Rixxi\\ComponentRegistry\\DI\\IComponentFactoriesProvider') as $provider) {
/* @var IComponentFactoriesProvider $provider */
$factories = $provider->getComponentFactories();
Validators::assert($factories, 'array');
$this->addComponentFactories($factories);
}
$this->addComponentFactories($config[self::FRAKKIN_KEY]);
$this->getContainerBuilder()->addDefinition($this->prefix('service'))->setClass('Rixxi\\ComponentRegistry\\ComponentRegistry');
}
public function loadConfiguration()
{
$builder = $this->getContainerBuilder();
$config = $this->getConfig($this->defaults);
Validators::assertField($config, 'clientId');
Validators::assertField($config, 'secret');
Validators::assertField($config, 'sdkConfig', 'array');
$builder->addDefinition($this->prefix('simplePaymentOperationFactory'))->setImplement('MetisFW\\PayPal\\Payment\\SimplePaymentOperationFactory');
$builder->addDefinition($this->prefix('plainPaymentOperationFactory'))->setImplement('MetisFW\\PayPal\\Payment\\PlainPaymentOperationFactory');
$builder->addDefinition($this->prefix('credentials'))->setClass('PayPal\\Auth\\OAuthTokenCredential', array($config['clientId'], $config['secret']));
$builder->addDefinition($this->prefix('apiContext'))->setClass('PayPal\\Rest\\ApiContext', array($this->prefix('@credentials')));
$builder->addDefinition($this->prefix('PayPal'))->setClass('MetisFW\\PayPal\\PayPalContext', array($this->prefix('@apiContext')))->addSetup('setConfig', array($config['sdkConfig']))->addSetup('setCurrency', array($config['currency']));
}
public function loadConfiguration()
{
$builder = $this->getContainerBuilder();
$config = $this->getConfig($this->defaults);
$reflectionReader = $builder->addDefinition($this->prefix('reflectionReader'))->setClass('Doctrine\\Common\\Annotations\\AnnotationReader')->setAutowired(FALSE);
Validators::assertField($config, 'ignore', 'array');
foreach ($config['ignore'] as $annotationName) {
$reflectionReader->addSetup('addGlobalIgnoredName', array($annotationName));
}
$builder->addDefinition($this->prefix('reader'))->setClass('Doctrine\\Common\\Annotations\\Reader')->setFactory('Doctrine\\Common\\Annotations\\CachedReader', array($this->prefix('@reflectionReader'), Helpers::processCache($this, $config['cache'], 'annotations'), $config['debug']))->setInject(FALSE);
// for runtime
AnnotationRegistry::registerLoader("class_exists");
}
public function loadConfiguration()
{
$config = $this->getConfig($this->defaults);
$builder = $this->getContainerBuilder();
Validators::assertField($config, 'enabled', 'boolean');
if ($config['enabled']) {
Validators::assertField($config, 'messageFactory', 'string');
Validators::assertField($config, 'slackUrl', 'string');
Validators::assertField($config, 'logUrl', 'string');
Validators::assertField($config, 'timeout', 'int');
$builder->addDefinition($this->prefix('messageFactory'))->setClass($config['messageFactory'])->setArguments([$config['defaults'], $config['logUrl']]);
}
}
/**
* Processes configuration data. Intended to be overridden by descendant.
* @return void
*/
public function loadConfiguration()
{
$builder = $this->getContainerBuilder();
$config = $this->validateConfig($this->defaults);
Validators::assertField($config, 'dir', 'string');
Validators::assertField($config, 'phpParams', 'array');
$dbal = $this->getDbal($config['dbal']);
$driver = $this->getDriver($config['driver'], $dbal);
$params = [$driver, $config['dir'], $config['phpParams']];
$builder->addExcludedClasses(['Nextras\\Migrations\\Bridges\\SymfonyConsole\\BaseCommand']);
$builder->addDefinition($this->prefix('continueCommand'))->setClass('Nextras\\Migrations\\Bridges\\SymfonyConsole\\ContinueCommand')->setArguments($params)->addTag('kdyby.console.command');
$builder->addDefinition($this->prefix('createCommand'))->setClass('Nextras\\Migrations\\Bridges\\SymfonyConsole\\CreateCommand')->setArguments($params)->addTag('kdyby.console.command');
$builder->addDefinition($this->prefix('resetCommand'))->setClass('Nextras\\Migrations\\Bridges\\SymfonyConsole\\ResetCommand')->setArguments($params)->addTag('kdyby.console.command');
}
public function loadConfiguration()
{
$builder = $this->getContainerBuilder();
$config = $this->getConfig($this->defaults);
Validators::assertField($config, 'account');
Validators::assertField($config, 'username');
Validators::assertField($config, 'password');
Validators::assertField($config, 'signature');
Validators::assertField($config, 'sandbox', 'bool');
$client = $builder->addDefinition($this->prefix('client'))->setClass('Kdyby\\PayPalExpress\\PayPal')->setArguments(array($config))->addSetup('setCurrency', array($config['currency']));
if ($config['sandbox'] === FALSE) {
$client->addSetup('disableSandbox');
}
}
/**
* @return Webhooks\Data
* @throws Utils\JsonException In case request body is not valid JSON
* @throws Utils\AssertionException In case request body is missing required keys
*/
public function create()
{
$data = Utils\Json::decode($this->request->getRawBody(), Utils\Json::FORCE_ARRAY);
Utils\Validators::assert($data, 'array', 'request body');
Utils\Validators::assertField($data, 'id', 'string', 'item % in request body');
Utils\Validators::assertField($data, 'suspectId', 'string', 'item % in request body');
Utils\Validators::assertField($data, 'externalId', 'string|null', 'item % in request body');
Utils\Validators::assertField($data, 'user', 'array', 'item % in request body');
Utils\Validators::assertField($data['user'], 'id', 'int', 'item % in user hash within request body');
Utils\Validators::assertField($data['user'], 'salescode', 'string', 'item % in user hash within request body');
Utils\Validators::assertField($data['user'], 'name', 'string', 'item % in user hash within request body');
Utils\Validators::assertField($data, 'data', 'array', 'item % in request body');
return new Webhooks\Data($id = $this->request->getHeader(Webhooks\Headers::IDENTIFIER), $interactionId = $data['id'], $suspectId = $data['suspectId'], $externalId = $data['externalId'], $campaignId = $this->request->getHeader(Webhooks\Headers::CAMPAIGN), $signature = $this->request->getHeader(Webhooks\Headers::SIGNATURE), $event = $this->request->getHeader(Webhooks\Headers::EVENT), $user = $data['user'], $suspectData = $data['data']);
}
public function loadConfiguration()
{
$config = $this->getConfig($this->defaults);
Validators::assertField($config, 'tempDir');
Validators::assertField($config, 'documentDir');
Validators::assertField($config, 'encoding');
Validators::assertField($config, 'img_dpi');
Validators::assertField($config, 'size');
Validators::assertField($config, 'orientation');
Validators::assertField($config, 'margin');
$builder = $this->getContainerBuilder();
$builder->addDefinition($this->prefix('settings'))->setClass('Pixidos\\PdfDocumentCreator\\DocumentCreatorSetting', [$config]);
$builder->addDefinition($this->prefix('default'))->setClass('Pixidos\\PdfDocumentCreator\\PdfDocumentCreatorProcesor');
}
