public function getAllProjects()
{
$key = "{$this->cachePrefix}-all-projects";
if ($this->cache && ($projects = $this->cache->fetch($key))) {
return $projects;
}
$first = json_decode($this->client->get('projects.json', ['query' => ['limit' => 100]])->getBody(), true);
$projects = $first['projects'];
if ($first['total_count'] > 100) {
$requests = [];
for ($i = 100; $i < $first['total_count']; $i += 100) {
$requests[] = $this->client->getAsync('projects.json', ['query' => ['limit' => 100, 'offset' => $i]]);
}
/** @var Response[] $responses */
$responses = Promise\unwrap($requests);
$responseProjects = array_map(function (Response $response) {
return json_decode($response->getBody(), true)['projects'];
}, $responses);
$responseProjects[] = $projects;
$projects = call_user_func_array('array_merge', $responseProjects);
}
usort($projects, function ($projectA, $projectB) {
return strcasecmp($projectA['name'], $projectB['name']);
});
$this->cache && $this->cache->save($key, $projects);
return $projects;
}
/**
* {@inheritdoc}
*/
public function deleteAll()
{
if ($this->cache instanceof ClearableCache) {
return $this->cache->deleteAll();
}
return false;
}
/**
* {@inheritdoc}
*/
public function load()
{
$contents = $this->doctrine->fetch($this->key);
if ($contents !== false) {
$this->setFromStorage($contents);
}
}
/**
* @param float $latitude
* @param float $longitude
* @return WeatherForecastForDay
*/
public function getForDay($latitude, $longitude, $timestamp)
{
if (!$this->isValidTimestamp($timestamp)) {
throw new \Exception('Invalid timestamp: ' . $timestamp);
}
if (!$this->isValidLatitude($latitude)) {
throw new \Exception('Invalid latitude: ' . $latitude);
}
if (!$this->isValidLongitude($longitude)) {
throw new \Exception('Invalid longitude: ' . $longitude);
}
$latitude = $this->normalizeGeoCoordinate($latitude);
$longitude = $this->normalizeGeoCoordinate($longitude);
$timestamp = $this->normalizeTimestamp($timestamp);
$cacheKey = md5($latitude . $longitude . $timestamp);
if (false === ($apiData = $this->cache->fetch($cacheKey))) {
try {
$apiData = $this->provider->getForDay($latitude, $longitude, $timestamp);
$this->cache->save($cacheKey, $apiData, 3600 * 6);
//TTL 6h
} catch (\Exception $e) {
return null;
}
}
return new WeatherForecastForDay($apiData);
}
/**
* @param $token
* @param AuthUser $user
* @return AccessToken
*/
public function insertAccessToken($token, AuthUser $user)
{
$accessToken = new AccessToken();
$accessToken->setCreatedAt(new \DateTime())->setId($token)->setUsername($user->getUsername());
$this->cache->save($token, $accessToken, 604800);
return $accessToken;
}
protected function saveCached(\Money\CurrencyPair $pair)
{
if ($this->cache) {
$cacheKey = $this->getCacheKey($pair->getCounterCurrency(), $pair->getBaseCurrency());
$this->cache->save($cacheKey, $pair, self::CACHE_LIFETIME);
}
}
/**
* Delete the cache keys
*
* @param Cache $cache
* @param array $keys
*/
protected function clearCache(Cache $cache, $keys)
{
$keys = array_unique($keys);
foreach ($keys as $key) {
$cache->delete($key);
}
}
/**
* @param BlockHeaderInterface $block
* @return bool
*/
public function save(BlockHeaderInterface $block)
{
$key = $this->cacheIndexBlk($block);
$this->blocks->save($key, $block);
$this->size++;
return $this;
}
public function find($id)
{
if (is_array($id)) {
$id = current($id);
}
return $this->cache->fetch($id) ?: null;
}
/**
* Get metadata for a certain class - loads once and caches
* @param string $className
* @throws \Drest\DrestException
* @return ClassMetaData $metaData
*/
public function getMetadataForClass($className)
{
if (isset($this->loadedMetadata[$className])) {
return $this->loadedMetadata[$className];
}
// check the cache
if ($this->cache !== null) {
$classMetadata = $this->cache->fetch($this->cache_prefix . $className);
if ($classMetadata instanceof ClassMetaData) {
if ($classMetadata->expired()) {
$this->cache->delete($this->cache_prefix . $className);
} else {
$this->loadedMetadata[$className] = $classMetadata;
return $classMetadata;
}
}
}
$classMetadata = $this->driver->loadMetadataForClass($className);
if ($classMetadata !== null) {
$this->loadedMetadata[$className] = $classMetadata;
if ($this->cache !== null) {
$this->cache->save($this->cache_prefix . $className, $classMetadata);
}
return $classMetadata;
}
if (is_null($this->loadedMetadata[$className])) {
throw DrestException::unableToLoadMetaDataFromDriver();
}
return $this->loadedMetadata[$className];
}
public function __construct(Cache $cache, ValidationService $validationService, Factory $factory = null)
{
$this->objects = $cache->fetch("agit.api.object") ?: [];
$this->factory = $factory;
AbstractType::setValidationService($validationService);
AbstractType::setObjectMetaService($this);
}
/**
* @Route("/entry-point/{mac}", defaults={"mac" = null})
* @Method({"GET", "POST"})
* @Template()
*/
public function indexAction(Request $request, $mac)
{
// Attempting to do anything here as a logged in user will fail. Set the current user token to null to log user out.
$this->get('security.token_storage')->setToken(null);
if (!$mac) {
if (!$request->getSession()->get('auth-data')) {
// No MAC code, nothing in the session, so we can't help - return to front page.
return $this->redirectToRoute('barbon_hostedapi_app_index_index');
}
} else {
$cacheKey = sprintf('mac-%s', $mac);
// If MAC isn't found in the cache, it's already been processed - redirect back to this route without the MAC, and try again.
if (!$this->cache->contains($cacheKey)) {
return $this->redirectToRoute('barbon_hostedapi_landlord_authentication_entrypoint_index');
}
// store data to session and empty the cache
$authData = unserialize($this->cache->fetch($cacheKey));
$request->getSession()->set('auth-data', $authData);
$this->cache->delete($cacheKey);
}
// Decide which tab should start as visible, so that is a registration attempt is in progress it re-shows that tab.
$selectedTab = $request->query->get('action') ?: 'register';
if ($request->isMethod(Request::METHOD_POST)) {
if ($request->request->has('direct_landlord')) {
$selectedTab = 'register';
}
}
return array('selectedTab' => $selectedTab);
}
public function getArguments(Request $request, $controller)
{
if (!is_array($controller)) {
throw new \InvalidArgumentException('Can not resolve arguments ' . 'for the controller type: "' . ($controller instanceof \Closure ? 'closure' : gettype($controller)) . '" for URI "' . $request->getPathInfo() . '"');
}
$id = get_class($controller[0]) . '::' . $controller[1] . '#method-parameters';
if (($parameters = $this->cacheProvider->fetch($id)) === false) {
$parameters = $this->getParameters($controller[0], $controller[1]);
$this->cacheProvider->save($id, $parameters);
}
$attributes = $request->attributes->all();
$arguments = array();
foreach ($parameters as $name => $options) {
if (array_key_exists($name, $attributes)) {
$arguments[] = $attributes[$name];
continue;
}
if (array_key_exists('defaultValue', $options)) {
$arguments[] = $options['defaultValue'];
continue;
}
throw new \RuntimeException('Controller ' . get_class($controller[0]) . '::' . $controller[1] . ' requires that you provide a value ' . 'for the "$' . $name . '" argument (because there is no default value or ' . 'because there is a non optional argument after this one).');
}
return $arguments;
}
/**
* {@inheritdoc}
*/
public function getMetadataFor($value)
{
$class = $this->getClass($value);
if (!$class) {
throw new InvalidArgumentException(sprintf('Cannot create metadata for non-objects. Got: "%s"', gettype($value)));
}
if (isset($this->loadedClasses[$class])) {
return $this->loadedClasses[$class];
}
if ($this->cache && ($this->loadedClasses[$class] = $this->cache->fetch($class))) {
return $this->loadedClasses[$class];
}
if (!class_exists($class) && !interface_exists($class)) {
throw new InvalidArgumentException(sprintf('The class or interface "%s" does not exist.', $class));
}
$classMetadata = new ClassMetadata($class);
$this->loader->loadClassMetadata($classMetadata);
$reflectionClass = $classMetadata->getReflectionClass();
// Include metadata from the parent class
if ($parent = $reflectionClass->getParentClass()) {
$classMetadata->merge($this->getMetadataFor($parent->name));
}
// Include metadata from all implemented interfaces
foreach ($reflectionClass->getInterfaces() as $interface) {
$classMetadata->merge($this->getMetadataFor($interface->name));
}
if ($this->cache) {
$this->cache->save($class, $classMetadata);
}
return $this->loadedClasses[$class] = $classMetadata;
}
/**
* Get the list of videos from YouTube
*
* @param string $channelId
* @throws \Mcfedr\YouTube\LiveStreamsBundle\Exception\MissingChannelIdException
* @return array
*/
public function getStreams($channelId = null)
{
if (!$channelId) {
$channelId = $this->channelId;
}
if (!$channelId) {
throw new MissingChannelIdException("You must specify the channel id");
}
if ($this->cache) {
$data = $this->cache->fetch($this->getCacheKey($channelId));
if ($data !== false) {
return $data;
}
}
$searchResponse = $this->client->get('search', ['query' => ['part' => 'id', 'channelId' => $channelId, 'eventType' => 'live', 'type' => 'video', 'maxResults' => 50]]);
$searchData = json_decode($searchResponse->getBody()->getContents(), true);
$videosResponse = $this->client->get('videos', ['query' => ['part' => 'id,snippet,liveStreamingDetails', 'id' => implode(',', array_map(function ($video) {
return $video['id']['videoId'];
}, $searchData['items']))]]);
$videosData = json_decode($videosResponse->getBody()->getContents(), true);
$streams = array_map(function ($video) {
return ['name' => $video['snippet']['title'], 'thumb' => $video['snippet']['thumbnails']['high']['url'], 'videoId' => $video['id']];
}, array_values(array_filter($videosData['items'], function ($video) {
return !isset($video['liveStreamingDetails']['actualEndTime']);
})));
if ($this->cache && $this->cacheTimeout > 0) {
$this->cache->save($this->getCacheKey($channelId), $streams, $this->cacheTimeout);
}
return $streams;
}
/**
* {@inheritdoc}
*/
public function clear($cacheDir)
{
if (!$this->cache instanceof ClearableCache) {
return;
}
$this->cache->deleteAll();
}
/**
* @param ServerRequestInterface $request
* @param ResponseInterface $response
* @param callable $next
* @return ResponseInterface
*/
public function __invoke(ServerRequestInterface $request, ResponseInterface $response, callable $next)
{
$key = $this->generateKey($request);
$data = $this->cache->fetch($key);
if (false !== $data) {
list($body, $code, $headers) = unserialize($this->cache->fetch($key));
$response->getBody()->write($body);
$response = $response->withStatus($code);
foreach (unserialize($headers) as $name => $value) {
$response = $response->withHeader($name, $value);
}
return $response;
}
// prepare headers
$ttl = $this->config['ttl'];
$response = $next ? $next($request, $response) : $response;
$response = $response->withHeader('Cache-Control', sprintf('public,max-age=%d,s-maxage=%d', $ttl, $ttl))->withHeader('ETag', $key);
// save cache - status code, headers, body
$body = $response->getBody()->__toString();
$code = $response->getStatusCode();
$headers = serialize($response->getHeaders());
$data = serialize([$body, $code, $headers]);
$this->cache->save($key, $data, $this->config['ttl']);
return $response;
}
/**
* {@inheritdoc}
*/
public function getMetadataFor($value)
{
$class = $this->getClass($value);
if (isset($this->loadedClasses[$class])) {
return $this->loadedClasses[$class];
}
if ($this->cache && ($this->loadedClasses[$class] = $this->cache->fetch($class))) {
return $this->loadedClasses[$class];
}
$classMetadata = new ClassMetadata($class);
$this->loader->loadClassMetadata($classMetadata);
$reflectionClass = $classMetadata->getReflectionClass();
// Include metadata from the parent class
if ($parent = $reflectionClass->getParentClass()) {
$classMetadata->merge($this->getMetadataFor($parent->name));
}
// Include metadata from all implemented interfaces
foreach ($reflectionClass->getInterfaces() as $interface) {
$classMetadata->merge($this->getMetadataFor($interface->name));
}
if ($this->cache) {
$this->cache->save($class, $classMetadata);
}
return $this->loadedClasses[$class] = $classMetadata;
}
/**
* {@inheritdoc}
*/
public function getMetadataFor($value)
{
$class = $this->getClass($value);
if (empty($class)) {
throw InvalidArgumentException::create(InvalidArgumentException::VALUE_IS_NOT_AN_OBJECT, $value);
}
if (isset($this->loadedClasses[$class])) {
return $this->loadedClasses[$class];
}
if (null !== $this->cache && ($this->loadedClasses[$class] = $this->cache->fetch($class))) {
return $this->loadedClasses[$class];
}
if (!class_exists($class) && !interface_exists($class)) {
throw InvalidArgumentException::create(InvalidArgumentException::CLASS_DOES_NOT_EXIST, $class);
}
$reflectionClass = new \ReflectionClass($class);
$classMetadata = $this->createMetadata($reflectionClass);
if (!$this->loader->loadClassMetadata($classMetadata)) {
return $classMetadata;
}
$this->mergeSuperclasses($classMetadata);
$this->validate($classMetadata);
if ($this->eventDispatcher) {
$this->eventDispatcher->dispatch(ClassMetadataLoadedEvent::LOADED_EVENT, new ClassMetadataLoadedEvent($classMetadata));
}
if (null !== $this->cache) {
$this->cache->save($class, $classMetadata);
}
return $this->loadedClasses[$class] = $classMetadata;
}
public function removeObject($object)
{
$class = $this->getClassMetadata();
$identifier = $this->getObjectIdentifier($object);
$identifier = $identifier[$class->identifier[0]];
$this->cache->delete($identifier);
}
/**
* @param int $start
* @param int $maxResults
* @return Category[]|null
* @throws RepositoryException
*/
public function findAll($start = 0, $maxResults = 100)
{
$cacheKey = self::CACHE_NAMESPACE . sha1($start . $maxResults);
if ($this->isCacheEnabled()) {
if ($this->cache->contains($cacheKey)) {
return $this->cache->fetch($cacheKey);
}
}
$compiledUrl = $this->baseUrl . "?start_element={$start}&num_elements={$maxResults}";
$response = $this->client->request('GET', $compiledUrl);
$repositoryResponse = RepositoryResponse::fromResponse($response);
if (!$repositoryResponse->isSuccessful()) {
throw RepositoryException::failed($repositoryResponse);
}
$stream = $response->getBody();
$responseContent = json_decode($stream->getContents(), true);
$stream->rewind();
$result = [];
if (!$responseContent['response']['content_categories']) {
$responseContent['response']['content_categories'] = [];
}
foreach ($responseContent['response']['content_categories'] as $segmentArray) {
$result[] = Category::fromArray($segmentArray);
}
if ($this->isCacheEnabled()) {
$this->cache->save($cacheKey, $result, self::CACHE_EXPIRATION);
}
return $result;
}
/**
* get config webhook for current webinstance
*
* @param $version
*
* @return mixed
*/
public function getCacheContext($version)
{
if (!($config = $this->cache->fetch($this->getCacheKey()))) {
$config = $this->createConfig($version);
$this->cache->save($this->getCacheKey(), $config, 86400);
}
return $config;
}
/**
* @param PersistConfigEvent $event
*/
public function persistConfig(PersistConfigEvent $event)
{
$event->getConfigManager()->calculateConfigChangeSet($event->getConfig());
$change = $event->getConfigManager()->getConfigChangeSet($event->getConfig());
if ($event->getConfig()->getId()->getScope() == 'email' && isset($change['available_in_template'])) {
$this->cache->delete($this->cacheKey);
}
}
/**
* Clears all cache entries.
*
* @throws \RuntimeException If the cache instance is not an instanceof Doctrine\Common\Cache\ClearableCache
*/
public function deleteAll()
{
if ($this->cache instanceof ClearableCache) {
$this->cache->deleteAll();
return;
}
throw new \RuntimeException('Cache given is not an instanceof Doctrine\\Common\\Cache\\ClearableCache');
}
/**
* {@inheritDoc}
*/
protected function internalRemoveItem(&$normalizedKey)
{
$key = $this->getOptions()->getNamespace() . $normalizedKey;
if (!$this->cache->contains($key)) {
return false;
}
return $this->cache->delete($key);
}
/**
* @param \databox[] $databoxes
*/
private function saveCache(array $databoxes)
{
$rows = array();
foreach ($databoxes as $databox) {
$rows[$databox->get_sbas_id()] = $databox->getRawData();
}
$this->cache->save($this->cacheKey, $rows);
}
/**
* Get the contents of an URI and cache it for CACHE_LIFETIME seconds.
*
* @param string $uri
* @return string
*/
public function getContents($uri)
{
if (!$this->cache->contains($uri)) {
$this->cache->save($uri, $contents = $this->download($uri), static::CACHE_LIFETIME);
return $contents;
}
return $this->cache->fetch($uri);
}
/**
* @param RequestInterface $request
* @param ResponseInterface $response
* @return bool true if success
*/
public function cache(RequestInterface $request, ResponseInterface $response)
{
try {
return $this->storage->save($this->getCacheKey($request), $this->getCacheObject($response));
} catch (\Exception $ignored) {
return false;
}
}
/**
* @return int
* @throws \Exception
*/
public function height()
{
$height = $this->index->fetch('height');
if (false === $height) {
throw new \Exception('Index not initialized with genesis block');
}
return $height;
}
public function remember($key, \closure $callable, $lifeTime = 0)
{
if ($this->cache->contains($key)) {
return $this->cache->fetch($key);
}
$data = $callable();
$this->cache->save($key, $data, $lifeTime);
return $data;
}