public function authenticate(array $credentials)
{
$mcrypt = mcrypt_module_open(MCRYPT_BLOWFISH, '', MCRYPT_MODE_CBC, '');
$iv = mcrypt_create_iv(mcrypt_enc_get_iv_size($mcrypt), MCRYPT_DEV_RANDOM);
mcrypt_generic_init($mcrypt, $this->cryptPassword, $iv);
$url = $this->getUrl($credentials[self::USERNAME], $credentials[self::PASSWORD], $mcrypt, $iv);
try {
$res = $this->httpClient->get($url)->send();
} catch (\Guzzle\Http\Exception\ClientErrorResponseException $e) {
if ($e->getResponse()->getStatusCode() === 403) {
throw new \Nette\Security\AuthenticationException("User '{$credentials[self::USERNAME]}' not found.", self::INVALID_CREDENTIAL);
} elseif ($e->getResponse()->getStatusCode() === 404) {
throw new \Nette\Security\AuthenticationException("Invalid password.", self::IDENTITY_NOT_FOUND);
} else {
throw $e;
}
}
$responseBody = trim(mdecrypt_generic($mcrypt, $res->getBody(TRUE)));
$apiData = Json::decode($responseBody);
$user = $this->db->table('users')->where('id = ?', $apiData->id)->fetch();
$registered = new \DateTimeImmutable($apiData->registered->date, new \DateTimeZone($apiData->registered->timezone));
$userData = array('username' => $credentials[self::USERNAME], 'password' => $this->calculateAddonsPortalPasswordHash($credentials[self::PASSWORD]), 'email' => $apiData->email, 'realname' => $apiData->realname, 'url' => $apiData->url, 'signature' => $apiData->signature, 'language' => $apiData->language, 'num_posts' => $apiData->num_posts, 'apiToken' => $apiData->apiToken, 'registered' => $registered->getTimestamp());
if (!$user) {
$userData['id'] = $apiData->id;
$userData['group_id'] = 4;
$this->db->table('users')->insert($userData);
$user = $this->db->table('users')->where('username = ?', $credentials[self::USERNAME])->fetch();
} else {
$user->update($userData);
}
return $this->createIdentity($user);
}
/**
* Funkce pro naparsování odpovědi získané od scoreru
* @param array|string $scorerResponseData
*/
private function parseResultResponse($scorerResponseData)
{
if (is_string($scorerResponseData)) {
$scorerResponseData = Json::decode($scorerResponseData);
}
#region score and rule
if (!empty($scorerResponseData['score'])) {
foreach ($scorerResponseData['score'] as $i => $rowResult) {
if ($rowResult == null) {
$this->classificationResults[] = null;
$this->rules[] = null;
continue;
}
if ($this->classificationAttribute == "") {
foreach ($rowResult as $key => $value) {
$this->classificationAttribute = $key;
break;
}
}
$this->classificationResults[] = @$rowResult[$this->classificationAttribute];
if (!empty($scorerResponseData['rule'][$i]) && !empty($scorerResponseData['rule'][$i]['id'])) {
$this->rules[] = $scorerResponseData['rule'][$i]['id'];
} else {
$this->rules[] = null;
}
}
}
#endregion score and rule
#region confusionMatrix
$this->confusionMatrix = new ScoringConfusionMatrix($scorerResponseData['confusionMatrix']['labels'], $scorerResponseData['confusionMatrix']['matrix']);
#endregion confusionMatrix
}
public function actionCreateOrder()
{
$post = $this->getHttpRequest()->getPost();
$data = Json::decode($post['data'], 1);
$this->orderManager->createOrder($data['language'], $data['products'], $data['customer']);
$this->terminate();
}
/**
* @return string
*/
public function getPanel()
{
if (!$this->queries) {
return NULL;
}
ob_start();
$esc = callback('Nette\\Templating\\Helpers::escapeHtml');
$click = class_exists('\\Tracy\\Dumper') ? function ($o, $c = FALSE, $d = 4) {
return \Tracy\Dumper::toHtml($o, array('collapse' => $c, 'depth' => $d));
} : callback('\\Tracy\\Helpers::clickableDump');
$totalTime = $this->totalTime ? sprintf('%0.3f', $this->totalTime * 1000) . ' ms' : 'none';
$extractData = function ($object) {
if ($object instanceof Elastica\Request) {
$data = $object->getData();
} elseif ($object instanceof Elastica\Response) {
$data = $object->getData();
} else {
return array();
}
try {
return !is_array($data) ? Json::decode($data, Json::FORCE_ARRAY) : $data;
} catch (Nette\Utils\JsonException $e) {
try {
return array_map(function ($row) {
return Json::decode($row, Json::FORCE_ARRAY);
}, explode("\n", trim($data)));
} catch (Nette\Utils\JsonException $e) {
return $data;
}
}
};
$processedQueries = array();
$allQueries = $this->queries;
foreach ($allQueries as $authority => $requests) {
/** @var Elastica\Request[] $item */
foreach ($requests as $i => $item) {
$processedQueries[$authority][$i] = $item;
if (isset($item[3])) {
continue;
// exception, do not re-execute
}
if (stripos($item[0]->getPath(), '_search') === FALSE || $item[0]->getMethod() !== 'GET') {
continue;
// explain only search queries
}
if (!is_array($data = $extractData($item[0]))) {
continue;
}
try {
$response = $this->client->request($item[0]->getPath(), $item[0]->getMethod(), $item[0]->getData(), array('explain' => 1) + $item[0]->getQuery());
// replace the search response with the explained response
$processedQueries[$authority][$i][1] = $response;
} catch (\Exception $e) {
// ignore
}
}
}
require __DIR__ . '/panel.phtml';
return ob_get_clean();
}
/**
* @param Request $request
* @return Notification
*/
public static function createFromRequest(Request $request)
{
$notification = new Notification();
$parsed = Json::decode($request->getRawBody());
$notification->setLive($parsed->live === 'true');
$items = array();
foreach ($parsed->notificationItems as $rawItem) {
$item = new NotificationRequestItem($notification);
$item->setAdditionalData(self::getNotificationRequestItemValue($rawItem, 'additionalData'));
$item->setAmountValue(self::getNotificationRequestItemValue($rawItem, 'amount.value'));
$item->setAmountCurrency(self::getNotificationRequestItemValue($rawItem, 'amount.currency'));
$item->setPspReference(self::getNotificationRequestItemValue($rawItem, 'pspReference'));
$item->setEventCode(self::getNotificationRequestItemValue($rawItem, 'eventCode'));
$date = new DateTime(self::getNotificationRequestItemValue($rawItem, 'eventDate'));
$item->setEventDate($date);
$item->setMerchantAccountCode(self::getNotificationRequestItemValue($rawItem, 'merchantAccountCode'));
$item->setOperations(self::getNotificationRequestItemValue($rawItem, 'operations'));
$item->setMerchantReference(self::getNotificationRequestItemValue($rawItem, 'merchantReference'));
$item->setOriginalReference(self::getNotificationRequestItemValue($rawItem, 'originalReference'));
$item->setPaymentMethod(self::getNotificationRequestItemValue($rawItem, 'paymentMethod'));
$item->setReason(self::getNotificationRequestItemValue($rawItem, 'reason'));
$item->setSuccess(self::getNotificationRequestItemValue($rawItem, 'success') === 'true');
$items[] = $item;
}
$notification->setNotificationItems($items);
return $notification;
}
/**
* Get plugins
*
* @param array $pluginsDirs Plugins directories
*
* @return array
*/
private function getPlugins(array $pluginsDirs)
{
$plugins = array();
foreach (Finder::findFiles("plugin.json")->from($pluginsDirs) as $plugin) {
$config = Json::decode(file_get_contents($plugin->getRealPath()), 1);
if (!isset($config["class"]) || !class_exists($config["class"])) {
continue;
}
// Get types
foreach (class_implements($config["class"]) as $interface) {
if (isset($this->pluginTypes[$interface])) {
$config["types"][$this->pluginTypes[$interface]] = true;
}
}
// Skip if unknown plugin type
if (empty($config["types"])) {
continue;
}
// Get plugin dir path
$config["path"] = dirname($plugin->getPathName());
// Get unique plugin name from class
$config["name"] = strtolower(stripslashes($config["class"]));
$plugins[$config["name"]] = $config;
}
return $plugins;
}
protected function process()
{
$v = $this->getValues();
/** @var Rme\Subject $subject */
$subject = $this->presenter->subject;
$subject->title = $v->title;
$subject->description = $v->description;
/** @var self|EditorSelector[] $this */
if ($this['editors']->isEditable()) {
$subject->editors = $v->editors;
}
$schemas = Json::decode($v['positions']);
foreach ($subject->schemas as $schema) {
$schema->position = NULL;
$schema->subject = NULL;
}
$position = 0;
foreach ($schemas as $schemaId) {
/** @var Rme\Schema $schema */
$schema = $this->orm->schemas->getById($schemaId);
$schema->position = $position;
$schema->subject = $subject;
$position++;
}
$this->orm->flush();
$this->presenter->flashSuccess('editor.edited.schema');
$this->presenter->purgeCacheTag('header');
$this->presenter->redirect('this');
}
public function loadConfiguration()
{
$builder = $this->getContainerBuilder();
$config = $this->getConfig($this->defaults);
$builder->addDefinition($this->prefix('helperSet'))->setClass('Symfony\\Component\\Console\\Helper\\HelperSet', array(array(new Nette\DI\Statement('Symfony\\Component\\Console\\Helper\\DialogHelper'), new Nette\DI\Statement('Symfony\\Component\\Console\\Helper\\FormatterHelper'), new Nette\DI\Statement('Symfony\\Component\\Console\\Helper\\ProgressHelper'), new Nette\DI\Statement('Kdyby\\Console\\Helpers\\PresenterHelper'))))->setInject(FALSE);
$builder->addDefinition($this->prefix('application'))->setClass('Kdyby\\Console\\Application', array($config['name'], $config['version']))->addSetup('setHelperSet', array($this->prefix('@helperSet')))->setInject(FALSE);
$builder->addDefinition($this->prefix('router'))->setClass('Kdyby\\Console\\CliRouter')->setAutowired(FALSE)->setInject(FALSE);
$builder->getDefinition('router')->addSetup('Kdyby\\Console\\CliRouter::prependTo($service, ?)', array($this->prefix('@router')));
$builder->getDefinition('nette.presenterFactory')->addSetup('if (method_exists($service, ?)) { $service->setMapping(array(? => ?)); } ' . 'elseif (property_exists($service, ?)) { $service->mapping[?] = ?; }', array('setMapping', 'Kdyby', 'KdybyModule\\*\\*Presenter', 'mapping', 'Kdyby', 'KdybyModule\\*\\*Presenter'));
if (!empty($config['url'])) {
if (!preg_match('~^https?://[^/]+\\.[a-z]+(/.*)?$~', $config['url'])) {
throw new Nette\Utils\AssertionException("The url '{$config['url']}' is not valid, please use this format: 'http://domain.tld/path'.");
}
$builder->getDefinition('nette.httpRequestFactory')->setClass('Kdyby\\Console\\HttpRequestFactory')->addSetup('setFakeRequestUrl', array($config['url']));
}
$builder->addDefinition($this->prefix('dicHelper'))->setClass('Kdyby\\Console\\ContainerHelper')->addTag(self::HELPER_TAG, 'dic');
Nette\Utils\Validators::assert($config, 'array');
foreach ($config['commands'] as $command) {
$def = $builder->addDefinition($this->prefix('command.' . md5(Nette\Utils\Json::encode($command))));
list($def->factory) = Nette\DI\Compiler::filterArguments(array(is_string($command) ? new Nette\DI\Statement($command) : $command));
if (class_exists($def->factory->entity)) {
$def->class = $def->factory->entity;
}
$def->setAutowired(FALSE);
$def->setInject(FALSE);
$def->addTag(self::COMMAND_TAG);
}
}
/**
* @secured
* @param $usersID
*/
public function handleDelete($usersID)
{
if (is_string($usersID)) {
try {
$usersID = (array) Json::decode($usersID);
$usersID = array_values($usersID);
} catch (JsonException $e) {
$this['notification']->addError($e->getMessage());
if ($this->isAjax()) {
$this['notification']->redrawControl('error');
}
}
}
$result = $this->userRepository->deactivate($usersID);
if ($result === TRUE) {
$this['notification']->addSuccess("Úspěšně deaktivováno...");
} else {
if (strpos("Integrity constraint violation", $result) != -1) {
$this['notification']->addError("Uživatele se nepovedlo deaktivovat.");
} else {
$this['notification']->addError($result);
}
}
if ($this->isAjax()) {
$this['notification']->redrawControl('error');
$this['notification']->redrawControl('success');
$this['grid']->redrawControl();
}
}
/**
* {inheritDoc}
*/
public function send(Nette\Http\IRequest $httpRequest, Nette\Http\IResponse $httpResponse)
{
$httpResponse->setContentType($this->getContentType(), 'utf-8');
$httpResponse->setExpiration(FALSE);
$httpResponse->setCode($this->code);
echo Nette\Utils\Json::encode($this->getPayload(), Nette\Utils\Json::PRETTY);
}
/**
* Funkce pro odeslání JSON odpovědi
* @param array|object|string $data
*/
protected function sendJsonResponse($data, $code = IResponse::S200_OK)
{
$httpResponse = $this->getHttpResponse();
$httpResponse->setContentType('application/json', 'UTF-8');
$httpResponse->setCode($code);
$this->sendResponse(new TextResponse(is_string($data) ? $data : Json::encode($data)));
}
/**
* funkce obstaravajici prihlaseni uzivatele
*/
private function login()
{
$this->database = $this->context->getService("database.default.context");
$data = Nette\Utils\Json::decode($this->request->getParameters()["data"]);
$authenticator = new LoginAuthenticator($this->database);
$user = $this->getUser();
$user->setAuthenticator($authenticator);
try {
$user->login($data->username, $data->password);
} catch (Nette\Security\AuthenticationException $e) {
$error["err"] = true;
$error["message"] = $e->getMessage();
return $error;
}
$userIdent = (array) $user->getIdentity()->getData();
$tokenId = base64_encode(mcrypt_create_iv(32));
$issuedAt = time();
$notBefore = $issuedAt;
$expire = $notBefore + 60 * 60;
$serverName = "lolnotepad";
$token = ['iat' => $issuedAt, 'jti' => $tokenId, 'iss' => $serverName, 'nbf' => $notBefore, 'exp' => $expire, 'data' => $userIdent];
$key = base64_decode(KEY);
$jwt = JWT::encode($token, $key, 'HS256');
return $jwt;
}
/**
* @param string $method
* @param string $endpoint
* @param array $parameters
* @return mixed
* @throws MailChimpException
*/
public function call($method = 'GET', $endpoint = '', array $parameters = [])
{
$uri = $this->config['apiUrl'] . (strlen($endpoint) && $endpoint[0] == '/' ? substr($endpoint, 1) : $endpoint);
$headers = ['Authorization' => 'apikey ' . $this->config['apiKey']];
try {
$body = $parameters ? Json::encode($parameters) : null;
} catch (JsonException $e) {
throw new MailChimpException('MailChimp request - invalid json', 667, $e);
}
$client = new Client();
$request = new Request($method, $uri, $headers, $body);
$resource = new Resource($request);
try {
/** @var \GuzzleHttp\Psr7\Response $response */
$response = $client->send($request);
$resource->setSuccessResponse($response);
} catch (GuzzleException $e) {
$resource->setErrorResponse($e);
}
$this->onResponse($resource);
if ($resource->getException()) {
throw new MailChimpException('MailChimp response - error', 666, $resource->getException());
} else {
return $resource->getResult();
}
}
public function create()
{
$form = new Form();
$form->addText('workStart', 'Začátek', 3, 5)->setRequired('Vyplňte pole "Začátek prac. doby".')->setDefaultValue($this->defaultItemTime['workStart'])->setHtmlId('workStart')->setAttribute('class', 'input-time')->addRule(Form::PATTERN, 'Do pole "Začátek prac. doby" lze zadat pouze
čas v 24 hodinovém formátu po půlhodinách.', '([01]?[0-9]|2[0-3]):(0|3)0');
$form->addText('workEnd', 'Konec', 3, 5)->setRequired('Vyplňte pole "Konec prac. doby".')->setDefaultValue($this->defaultItemTime['workEnd'])->setHtmlId('workEnd')->setAttribute('class', 'input-time')->addRule(Form::PATTERN, 'Do pole "Konec prac. doby" lze zadat pouze
čas v 24 hodinovém formátu po půlhodinách.', '([01]?[0-9]|2[0-3]):(0|3)0');
$form->addText('lunch', 'Oběd', 3, 5)->setRequired('Vyplňte pole "Oběd".')->setDefaultValue($this->defaultItemTime['lunch'])->setHtmlId('lunch')->setAttribute('class', 'input-time')->addRule(Form::PATTERN, 'Do pole "Oběd" lze zadat pouze
čas v ve formátu s čárkou. (např. 1 nebo 1,5)', '^(0|[1-9]|1[0-9]|2[0-3])(,(0|5))?$');
$form->addText('otherHours', 'Ostatní hod.')->setDefaultValue($this->defaultItemTime['otherHours'])->setHtmlId('otherHours')->setAttribute('class', 'input-time')->addCondition(Form::FILLED)->addRule(Form::PATTERN, 'Do pole "Ostaní hodiny" lze zadat pouze
čas ve formátu s čárkou.(např. 6 nebo 6,5)', '^(0|[1-9]|1[0-9]|2[0-3])(,(0|5))?$');
$form->addText('locality', 'Místo pracoviště', 28, 40)->setRequired('Vyplňte pole "Místo pracoviště".')->setHtmlId('locality')->getControlPrototype()->class = 'item-text-input';
$form->addText('description', 'Popis práce', 28, 30)->getControlPrototype()->class = 'item-text-input';
$form->addText('descOtherHours', 'Komentář k ostat. hod. (např. svátek)', 28, 30)->addConditionOn($form['otherHours'], Form::FILLED)->addCondition(Form::FILLED)->addRule(function ($item, $arg) {
return \InvoiceTime::processTime($arg) == '00:00:00' ? false : true;
}, self::OTHER_HOURS_ZERO_TIME_ERROR_MSG, $form['otherHours']);
$form['descOtherHours']->getControlPrototype()->class = 'item-text-input';
// time control buttons
$form->addButton('workStartAdd', '+')->setAttribute('class', self::BTN_TIME_ADD_CLASS)->setAttribute('data-time', Json::encode(['inputID' => $form['workStart']->control->attrs['id'], 'slider' => 'slider_range', 'pos' => 0, 'val' => -30]));
$form->addButton('workStartSub', '-')->setAttribute('class', self::BTN_TIME_SUB_CLASS)->setAttribute('data-time', Json::encode(['inputID' => $form['workStart']->control->attrs['id'], 'slider' => 'slider_range', 'pos' => 0, 'val' => 30]));
$form->addButton('workEndAdd', '+')->setAttribute('class', self::BTN_TIME_ADD_CLASS)->setAttribute('data-time', Json::encode(['inputID' => $form['workEnd']->control->attrs['id'], 'slider' => 'slider_range', 'pos' => 1, 'val' => 30]));
$form->addButton('workEndSub', '-')->setAttribute('class', self::BTN_TIME_SUB_CLASS)->setAttribute('data-time', Json::encode(['inputID' => $form['workEnd']->control->attrs['id'], 'slider' => 'slider_range', 'pos' => 1, 'val' => -30]));
$form->addButton('lunchAdd', '+')->setAttribute('class', self::BTN_TIME_ADD_CLASS)->setAttribute('data-time', Json::encode(['inputID' => $form['lunch']->control->attrs['id'], 'slider' => 'slider_lunch', 'val' => -30]));
$form->addButton('lunchSub', '-')->setAttribute('class', self::BTN_TIME_SUB_CLASS)->setAttribute('data-time', Json::encode(['inputID' => $form['lunch']->control->attrs['id'], 'slider' => 'slider_lunch', 'val' => 30]));
$form->addButton('otherHoursAdd', '+')->setAttribute('class', self::BTN_TIME_ADD_CLASS)->setAttribute('data-time', Json::encode(['inputID' => $form['otherHours']->control->attrs['id'], 'slider' => 'slider_time_other', 'val' => 0]));
$form->addButton('otherHoursSub', '-')->setAttribute('class', self::BTN_TIME_SUB_CLASS)->setAttribute('data-time', Json::encode(['inputID' => $form['otherHours']->control->attrs['id'], 'slider' => 'slider_time_other', 'val' => 0]));
$form->addSubmit('save', 'Uložit řádek');
$form->getElementPrototype()->id = 'update-form';
return $form;
}
public function send(RequestInterface $request)
{
try {
return parent::send($request);
} catch (\GuzzleHttp\Exception\ServerException $e) {
$response = $e->getResponse();
$body = $response->getBody()->getContents();
$message = $e->getMessage();
try {
$data = Json::decode($body);
$message = implode(', ', $data->errors);
} catch (JsonException $e) {
//ignore
}
$ex = new ServerException($message, $e->getCode(), $e);
$ex->setBody($body);
throw $ex;
} catch (\GuzzleHttp\Exception\ClientException $e) {
$response = $e->getResponse();
$body = $response->getBody()->getContents();
$message = $e->getMessage();
try {
$data = Json::decode($body);
$message = implode(', ', $data->errors);
} catch (JsonException $e) {
//ignore
}
$ex = new ClientException($message, $e->getCode(), $e);
$ex->setBody($body);
throw $ex;
}
}
private function request($req, $args = [])
{
$args = $args + ['api_key' => $this->apiKey, 'api_username' => $this->apiUsername];
$url = self::DOMAIN . "{$req}?" . http_build_query($args);
$raw = file_get_contents($url);
return Json::decode($raw, Json::FORCE_ARRAY);
}
private function updateAddon(ActiveRow $addon)
{
$this->writeln('Updating: ' . $addon->name);
$github = $this->normalizeGithubUrl($addon->repository);
if ($github) {
$guzzle = new \Guzzle\Http\Client();
try {
$guzzle->get($github)->send();
$this->db->table('addons_resources')->insert(array('addonId' => $addon->id, 'type' => 'github', 'resource' => $github));
} catch (\Guzzle\Http\Exception\RequestException $e) {
$this->writeln((string) $e);
}
}
if ($addon->type === 'composer') {
$version = $addon->related('versions')->order('id', 'DESC')->fetch();
$composerData = Json::decode($version->composerJson);
$packagist = $this->generatePackagistUrl($composerData->name);
$guzzle = new \Guzzle\Http\Client();
try {
$guzzle->get($packagist . '.json')->send();
$this->db->table('addons_resources')->insert(array('addonId' => $addon->id, 'type' => 'packagist', 'resource' => $packagist));
} catch (\Guzzle\Http\Exception\RequestException $e) {
$this->writeln((string) $e);
}
}
if ($addon->demo) {
$guzzle = new \Guzzle\Http\Client();
try {
$guzzle->get($addon->demo)->send();
$this->db->table('addons_resources')->insert(array('addonId' => $addon->id, 'type' => 'demo', 'resource' => $addon->demo));
} catch (\Guzzle\Http\Exception\RequestException $e) {
$this->writeln((string) $e);
}
}
}
/**
* @param string $method
* @param string $endpoint
* @param array $data
*
* @return \Kdyby\Curl\Response|NULL
*/
private function call($method, $endpoint, $data = [])
{
$request = $this->createRequest($endpoint);
$data = Json::encode($data);
try {
if ($method === Request::GET) {
$response = $request->get($data);
} else {
$request->post = $data;
$request->setMethod($method);
$response = $request->send();
}
} catch (CurlException $e) {
if ($e instanceof BadStatusException) {
$response = $e->getResponse();
if ($response->getCode() !== 404) {
Debugger::log($e);
return NULL;
}
} else {
throw $e;
}
}
return $response;
}
public function onUpload(Form $form)
{
/** @var UploadControl[] $form */
/** @var FileUpload $json */
/** @var FileUpload $audio */
$json = $form['json']->getValue();
$audio = $form['audio']->getValue();
$data = Json::decode($json->getContents(), Json::FORCE_ARRAY);
$blackboard = new Rme\Blackboard();
$this->orm->contents->attach($blackboard);
$blackboard->title = 'Nová nahrávka';
$blackboard->description = ' ';
$blackboard->hidden = TRUE;
$blackboard->duration = $data['duration'];
$blackboard->preview = 'https://placehold.it/480x320&text=...';
$blackboard->author = $this->userEntity;
$this->orm->flush();
$base = $this->paths->getBlackboards() . "/{$blackboard->id}";
$json->move("{$base}.json");
$audio->move("{$base}.wav");
$producer = $this->queue->getProducer('blackboardPreview');
$producer->publish(serialize(['blackboard' => new EntityPointer($blackboard)]));
$link = $this->link('BlackboardEditor:default', ['blackboardId' => $blackboard->id]);
$this->sendJson(['redirect' => $link]);
}
public function __construct($domain, $apiKey = NULL, $apiSecret = NULL)
{
$this->domain = $domain;
$this->apiKey = $apiKey;
$this->apiSecret = $apiSecret;
$config = ['base_url' => $domain];
$curl = new Client($config);
$curl->onBeforeRequest[] = function (Curl\Request $request) {
$data = $request->getData();
$timestamp = time();
$toSign = $data;
$toSign['timestamp'] = (int) $timestamp;
$toSign['apiKey'] = $this->apiKey;
ksort($toSign);
$json = \Nette\Utils\Json::encode($toSign);
$signature = base64_encode(hash_hmac('sha512', $json, $this->apiSecret, $raw = TRUE));
$request->setQuery('apiKey', $this->apiKey);
$request->setQuery('timestamp', $timestamp);
$request->setQuery('signature', $signature);
};
$curl->onBeforeResponse[] = function ($response) {
return ResponseParser::parse($response);
};
$this->clients = new Clients($curl);
$this->products = new Products($curl);
$this->orders = new Orders($curl);
$this->invoices = new Invoices($curl);
}
protected function execute(Console\Input\InputInterface $input, Console\Output\OutputInterface $output)
{
$output->writeln('Extracting files');
$outputFolder = $input->getOption('o');
if ($outputFolder === NULL) {
$outputFolder = $this->outputFolder;
}
$files = $input->getOption('f');
if ($files === NULL) {
$files = $this->extractDirs;
}
if (!isset($files)) {
$output->writeln('No input files given.');
exit;
}
$remote = $input->getOption('r');
if ($remote === NULL) {
$remote = $this->remote;
} else {
$remote = (bool) $remote;
}
$extractor = new NetteExtractor();
$extractor->setupForms()->setupDataGrid();
$data = $extractor->scan($files);
$builder = new TemplateBuilder();
if ($remote === TRUE) {
$templateData = $builder->formatTemplateData($data);
$response = \Nette\Utils\Json::decode($this->uploader->upload($templateData));
$output->writeln(sprintf('<info>Extracted %d tokens. Uploaded to remote server. Response: %s</info>', count($data), $response->message));
} else {
$outputFile = $outputFolder . '/template.neont';
$builder->buildTemplate($outputFile, $data);
$output->writeln(sprintf('<info>Extracted %d tokens. Output saved in: %s.</info>', count($data), $outputFile));
}
}
/**
* @param string $method "/tag"
* @param array $args [data => string]
* @return mixed
* @throws \Nette\Utils\JsonException
*/
protected function request($method, $args)
{
$args = $args + ['output' => 'json'];
$url = self::ENDPOINT . "{$method}?" . http_build_query($args);
$raw = file_get_contents($url);
return Json::decode($raw, Json::FORCE_ARRAY)['result'];
}
public static function fromActiveRow(ActiveRow $row)
{
$version = new static();
$version->id = $row->id;
$version->version = $row->version;
$version->license = $row->license;
$version->distType = $row->distType;
$version->distUrl = $row->distUrl;
$version->sourceType = $row->sourceType;
$version->sourceUrl = $row->sourceUrl;
$version->sourceReference = $row->sourceReference;
$version->composerJson = Json::decode($row->composerJson);
// this may fail
$version->updatedAt = $row->updatedAt;
$linkTypes = self::getLinkTypes();
$linkTypes = array_flip($linkTypes);
foreach ($row->related('dependencies') as $dependencyRow) {
$type = $dependencyRow->type;
$type = $linkTypes[$type];
$version->{$type}[$dependencyRow->packageName] = $dependencyRow->version;
if ($dependencyRow->dependencyId) {
$version->relatedAddons[$dependencyRow->packageName] = $dependencyRow->dependencyId;
}
}
return $version;
}
/**
* @param string|object $json
* @param int $forcedDepth
* @return \SimpleXMLElement
*/
public function settingsFromJson($json, $forcedDepth = 3)
{
if (is_string($json)) {
$json = Json::decode($json);
}
$strict = $json->strict;
$rule = $json->rule0;
// Create basic structure of Document.
//TODO taskId
$this->init(!empty($json->taskId) ? $json->taskId : '', $json->limitHits);
// Create antecedent
if (!empty($rule->antecedent->children)) {
$antecedentId = $this->parseCedent($rule->antecedent, 1, $forcedDepth, $strict);
$this->antecedentSetting[0] = (string) $antecedentId;
}
// IMs
foreach ($rule->IMs as $IM) {
$this->createInterestMeasureThreshold($IM);
}
if (!empty($rule->specialIMs)) {
foreach ($rule->specialIMs as $IM) {
$this->createInterestMeasureThreshold($IM);
}
}
// Create consequent
$consequentId = $this->parseCedent($rule->succedent, 1, $forcedDepth, $strict);
$this->consequentSetting[0] = (string) $consequentId;
return $this->pmml;
}
/**
* Generates control's HTML element
*
* @return Html
*/
public function getControl()
{
$control = parent::getControl()->addClass('pswdinput');
$this->data['fid'] = $this->getForm()->getElementPrototype()->id;
$control->data('lohini-pswd', \Nette\Utils\Json::encode(array_filter($this->data)));
return Html::el('span', ['style' => 'position: relative; float: left;'])->add($control);
}
public function loadConfiguration()
{
$builder = $this->getContainerBuilder();
$config = $this->getConfig($this->defaults);
$helperClasses = array('Symfony\\Component\\Console\\Helper\\FormatterHelper', 'Symfony\\Component\\Console\\Helper\\QuestionHelper', 'Kdyby\\Console\\Helpers\\PresenterHelper');
$helperClasses = array_map(function ($class) {
return new Nette\DI\Statement($class);
}, $helperClasses);
if (class_exists('Symfony\\Component\\Console\\Helper\\ProgressHelper')) {
$helperClasses[] = new Nette\DI\Statement('Symfony\\Component\\Console\\Helper\\ProgressHelper', array(false));
}
if (class_exists('Symfony\\Component\\Console\\Helper\\DialogHelper')) {
$helperClasses[] = new Nette\DI\Statement('Symfony\\Component\\Console\\Helper\\DialogHelper', array(false));
}
$builder->addDefinition($this->prefix('helperSet'))->setClass('Symfony\\Component\\Console\\Helper\\HelperSet', array($helperClasses))->setInject(FALSE);
$builder->addDefinition($this->prefix('application'))->setClass('Kdyby\\Console\\Application', array($config['name'], $config['version']))->addSetup('setHelperSet', array($this->prefix('@helperSet')))->addSetup('injectServiceLocator')->setInject(FALSE);
$builder->addDefinition($this->prefix('dicHelper'))->setClass('Kdyby\\Console\\ContainerHelper')->addTag(self::TAG_HELPER, 'dic');
if ($config['disabled']) {
return;
}
$builder->addDefinition($this->prefix('router'))->setClass('Kdyby\\Console\\CliRouter')->setAutowired(FALSE)->setInject(FALSE);
Nette\Utils\Validators::assert($config, 'array');
foreach ($config['commands'] as $command) {
$def = $builder->addDefinition($this->prefix('command.' . md5(Nette\Utils\Json::encode($command))));
list($def->factory) = Nette\DI\Compiler::filterArguments(array(is_string($command) ? new Nette\DI\Statement($command) : $command));
if (class_exists($def->factory->entity)) {
$def->class = $def->factory->entity;
}
$def->setAutowired(FALSE);
$def->setInject(FALSE);
$def->addTag(self::TAG_COMMAND);
}
}
public function __construct(OAuth\Consumer $consumer, Http\Url $url, $method = self::GET, array $post = [], array $headers = [], OAuth\Token $token = NULL)
{
$this->consumer = $consumer;
$this->token = $token;
$this->url = $url;
$this->method = strtoupper($method);
$this->headers = $headers;
if (is_array($post) && !empty($post)) {
$this->post = array_map(function ($value) {
if ($value instanceof Http\UrlScript) {
return (string) $value;
} elseif ($value instanceof \CURLFile) {
return $value;
}
return !is_string($value) ? Utils\Json::encode($value) : $value;
}, $post);
}
$parameters = $this->getParameters();
$defaults = ['oauth_version' => OAuth\DI\OAuthExtension::VERSION, 'oauth_nonce' => $this->generateNonce(), 'oauth_timestamp' => $this->generateTimestamp(), 'oauth_consumer_key' => $this->consumer->getKey()];
if ($token && $token->getToken()) {
$defaults['oauth_token'] = $this->token->getToken();
}
// Update query parameters
$this->url->setQuery(array_merge($defaults, $parameters));
}
/**
* @param Screenplay[] $scenarios
*/
public function publish(array $scenarios)
{
$ids = [];
foreach ($scenarios as $screenplay) {
$ids[] = $screenplay->getId();
}
$this->producer->publish(Json::encode($ids));
}
private function parse($input)
{
try {
return Json::decode($input);
} catch (JsonException $exception) {
throw new TransitException('Input is not valid transit.');
}
}
/**
* @param Http\IRequest $request
* @param Http\IResponse $response
*/
public function send(Http\IRequest $request, Http\IResponse $response)
{
$response->setContentType($this->contentType);
$response->setCode($this->code ?: Http\IResponse::S200_OK);
$response->setExpiration($this->expiration);
$response->setHeader('Pragma', $this->expiration ? 'cache' : 'no-cache');
echo Json::encode($this->data);
}