/**
* @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);
}
/**
* {@inheritdoc}
*/
public function removeTags(array $tags)
{
foreach ($tags as $tag) {
// doctrine does not care if the key does not exist.
$this->cache->delete($tag);
}
}
/**
* 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 removeObject($object)
{
$class = $this->getClassMetadata();
$identifier = $this->getObjectIdentifier($object);
$identifier = $identifier[$class->identifier[0]];
$this->cache->delete($identifier);
}
/**
* {@inheritdoc}
*/
public function deleteItem($key)
{
if (!is_string($key)) {
throw new InvalidArgumentException('Passed key is invalid');
}
return $this->cache->delete($key);
}
/**
* {@inheritdoc}
*/
public function stop($token)
{
if (!$this->exists($token)) {
return;
}
$this->dataCache->delete($token);
}
/**
* {@inheritDoc}
*/
protected function internalRemoveItem(&$normalizedKey)
{
$key = $this->getOptions()->getNamespace() . $normalizedKey;
if (!$this->cache->contains($key)) {
return false;
}
return $this->cache->delete($key);
}
/**
* @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);
}
}
/**
* Set the state.
*
* @param bool $ok
* @param string|null $name
*/
public function ok($ok, $name = null)
{
$ok = (bool) $ok;
$key = $this->getCacheKey($name);
if ($ok === true) {
$this->cache->delete($key);
} else {
$this->cache->save($key, 1, $this->ttl);
}
}
/**
* @param PersistConfigEvent $event
*/
public function persistConfig(PersistConfigEvent $event)
{
$config = $event->getConfig();
if ($config->getId()->getScope() !== 'email') {
return;
}
$change = $event->getConfigManager()->getConfigChangeSet($config);
if (isset($change['available_in_template'])) {
$this->cache->delete($this->cacheKey);
}
}
/**
* @param PreFlushConfigEvent $event
*/
public function preFlush(PreFlushConfigEvent $event)
{
$config = $event->getConfig('email');
if (null === $config || $event->isEntityConfig()) {
return;
}
$changeSet = $event->getConfigManager()->getConfigChangeSet($config);
if (isset($changeSet['available_in_template'])) {
$this->cache->delete($this->cacheKey);
}
}
public function reset($class = null)
{
if ($class === null) {
if ($this->cacheProvider instanceof \Doctrine\Common\Cache\FlushableCache) {
$this->cacheProvider->flushAll();
}
return parent::reset($class);
}
$id = $class . '#info';
$this->cacheProvider->delete($id);
return parent::reset($class);
}
/** @inheritdoc */
public function invalidate($restaurantId)
{
if ($this->cache->contains($restaurantId)) {
$cached = $this->cache->fetch($restaurantId)['cached']->getTimestamp();
$now = (new \DateTime())->getTimestamp();
if ($now - $cached < 60) {
throw new EnhanceYourCalmException();
}
$this->cache->delete($restaurantId);
return true;
}
return false;
}
protected function removePathAndFilter($path, $filter)
{
$indexKey = $this->generateIndexKey($this->generateCacheKey($path, $filter));
if (!$this->cache->contains($indexKey)) {
return;
}
$index = $this->cache->fetch($indexKey);
if (null === $path) {
foreach ($index as $eachCacheKey) {
$this->cache->delete($eachCacheKey);
}
$index = array();
} else {
$cacheKey = $this->generateCacheKey($path, $filter);
if (false !== ($indexIndex = array_search($cacheKey, $index))) {
unset($index[$indexIndex]);
$this->cache->delete($cacheKey);
}
}
if (empty($index)) {
$this->cache->delete($indexKey);
} else {
$this->cache->save($indexKey, $index);
}
}
/**
* {@inheritdoc}
*/
public function removeRolePermission(Role $role, Permission $permission)
{
$this->driver->removeRolePermission($role, $permission);
// Invalidate cache
$cacheId = sprintf('roles/%s', $role->getRoleName());
$this->cache->delete($cacheId);
}
/**
* 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);
}
}
/**
* {@inheritdoc}
*/
public function deleteItem($key, array $tags = array())
{
if (!is_string($key)) {
throw new InvalidArgumentException('Passed key is invalid');
}
$taggedKey = $this->generateCacheKey($key, $tags);
return $this->cache->delete($taggedKey);
}
/**
* {@inheritDoc}
*/
public function deleteDir($dirname)
{
$success = $this->adapter->deleteDir($dirname);
if ($success) {
$this->cache->delete($this->getCacheKey($dirname));
}
return $success;
}
/**
* Resets the cache
*/
public function reset()
{
for ($i = $this->getStart(), $end = $this->getEnd(); $i < $end; $i++) {
$this->cache->delete($i);
}
$this->cache->save('start', 0);
$this->cache->save('end', 0);
}
/**
* @param object $object
*
* @return bool
*/
public function remove($object)
{
$className = get_class($object);
$this->cache->setNamespace($className);
$tags = $object->getTags();
$id = $this->getRepository($className)->getId($tags);
return $this->cache->delete($id);
}
/**
* {@inheritdoc}
*/
public function delete($userId, $contentUuid, $webspaceKey, $locale)
{
$id = $this->getId($userId, $contentUuid, $locale);
$classId = $this->getId($userId, $contentUuid, $locale, 'class');
$this->dataCache->delete($id);
$this->dataCache->delete($classId);
$this->changesCache->delete($id);
}
/**
* Clear a cache entry
*
* @param string $name Entry name
*/
private function clearCacheEntry($name)
{
if ($this->cache === null) {
return;
}
$cacheKey = self::CACHE_PREFIX . $name;
$this->cache->delete($cacheKey);
}
public function fetch(RequestInterface $request)
{
$key = $this->getCacheKey($request);
$entries = $this->cache->fetch($key);
if (!$entries) {
return null;
}
$match = $matchIndex = null;
$headers = $this->persistHeaders($request);
$entries = unserialize($entries);
foreach ($entries as $index => $entry) {
$vary = isset($entry[1]['vary']) ? $entry[1]['vary'] : '';
if ($this->requestsMatch($vary, $headers, $entry[0])) {
$match = $entry;
$matchIndex = $index;
break;
}
}
if (!$match) {
return null;
}
// Ensure that the response is not expired
$response = null;
if ($match[4] < time()) {
$response = -1;
} else {
$response = new Response($match[2], $match[1]);
if ($match[3]) {
if ($body = $this->cache->fetch($match[3])) {
$response->setBody(Stream\Utils::create($body));
} else {
// The response is not valid because the body was somehow
// deleted
$response = -1;
}
}
}
if ($response === -1) {
// Remove the entry from the metadata and update the cache
unset($entries[$matchIndex]);
if ($entries) {
$this->cache->save($key, serialize($entries));
} else {
$this->cache->delete($key);
}
return null;
}
return $response;
}
/**
* @param string $class
*
* @return object
*/
private function recompile($class)
{
$this->cache->delete($this->cacheKey);
$diCompiler = $this->injector ? $this : call_user_func_array([$this, 'createInstance'], self::$args);
/** @var $diCompiler DiCompiler */
$mappedClass = array_keys($this->classMap);
$mappedClass[] = $class;
foreach ($mappedClass as $newClass) {
$diCompiler->compile($newClass);
}
// log dependency container
// error_log($this->logger);
$instance = $this->getInstanceSafe($diCompiler, $class);
return $instance;
}
/**
* @param $id
* @param $refreshToken
* @return array|void
*/
public function refreshAccess($id, $refreshToken, $force = false)
{
$fromcache = true;
if ($force) {
$this->cache->delete($id . '_token');
}
if (!($jsontoken = $this->cache->fetch($id . '_token'))) {
try {
$this->googleclient->refreshToken($refreshToken);
$verify_token = $this->googleclient->verifyIdToken();
if ($verify_token->getUserId() != $id) {
return;
}
$jsontoken = $this->googleclient->getAccessToken();
} catch (\Exception $e) {
$this->lastexception = $e;
$this->cache->delete($id . '_token');
return;
}
$fromcache = false;
$fulltoken = json_decode($jsontoken, true);
if (!$this->cache->save($id . '_token', $jsontoken, $fulltoken["expires_in"] - 60)) {
return;
}
}
try {
$this->googleclient->setAccessToken($jsontoken);
$fulltoken = json_decode($jsontoken, true);
$fulltoken["refresh_token"] = $refreshToken;
$this->setAdwordsOAuth2Validate($fulltoken);
$service = new \Google_Service_Oauth2($this->googleclient);
$tokeninfo = $service->tokeninfo(array("access_token" => $fulltoken["access_token"]));
} catch (\Exception $e) {
$this->lastexception = $e;
$this->cache->delete($id . '_token');
return;
}
return array("accessType" => $tokeninfo->accessType, "audience" => $tokeninfo->audience, "email" => $tokeninfo->email, "expiresIn" => $tokeninfo->expiresIn, "issuedTo" => $tokeninfo->issuedTo, "scope" => $tokeninfo->scope, "userId" => $tokeninfo->userId, "verifiedEmail" => $tokeninfo->verifiedEmail, "fromcache" => $fromcache, "force" => $force);
}
/**
* Removes the collaborator with the given userId from the entity with the given identifier.
*
* @param string $type The type of the entity
* @param mixed $id The id of the entity
* @param string $connectionId The id of the connection of the user
*/
private function removeCollaboration($type, $id, $connectionId)
{
$identifier = $this->getUniqueCollaborationKey($type, $id);
$entityCollaborations = $this->collaborationsEntityCache->fetch($identifier) ?: [];
if (array_key_exists($connectionId, $entityCollaborations)) {
unset($entityCollaborations[$connectionId]);
}
if (empty($entityCollaborations)) {
$this->collaborationsEntityCache->delete($identifier);
} else {
$this->collaborationsEntityCache->save($identifier, $entityCollaborations);
}
$connectionCollaborations = $this->collaborationsConnectionCache->fetch($connectionId) ?: [];
if (array_key_exists($identifier, $connectionCollaborations)) {
unset($connectionCollaborations[$identifier]);
}
if (empty($connectionCollaborations)) {
$this->collaborationsConnectionCache->delete($connectionId);
} else {
$this->collaborationsConnectionCache->save($connectionId, $connectionCollaborations);
}
}
/**
* {@inheritDoc}
*/
public function remove($targetPath, $filter)
{
$removed = $this->resolver->remove($targetPath, $filter);
// If the resolver did not remove the content, we can leave the cache.
if ($removed) {
$reverseKey = $this->generateCacheKey('reverse', $targetPath, $filter);
if ($this->cache->contains($reverseKey)) {
$path = $this->cache->fetch($reverseKey);
// The indexKey is not utilizing the method so the value is not important.
$indexKey = $this->generateIndexKey($this->generateCacheKey(null, $path, $filter));
// Retrieve the index and remove the content from the cache.
$index = $this->cache->fetch($indexKey);
foreach ($index as $eachCacheKey) {
$this->cache->delete($eachCacheKey);
}
// Remove the auxiliary keys.
$this->cache->delete($indexKey);
$this->cache->delete($reverseKey);
}
}
return $removed;
}
/**
* @param $method
* @param $resource
* @param array $request
* @param array $headers
* @param int $returnType
* @return array|mixed|string|resource
*/
protected function performRequest($method, $resource, array $request, array $headers, $returnType = HttpAdapter::RETURN_TYPE_JSON)
{
if ($this->cache->contains($this->options['cache_key'])) {
$accessToken = $this->cache->fetch($this->options['cache_key']);
} else {
$accessToken = $this->authorize();
$this->cache->save($this->options['cache_key'], $accessToken);
}
try {
$request['access_token'] = $accessToken;
return $this->http->{$method}($resource, $request, $headers, $returnType);
} catch (UnauthorizedException $e) {
if (!$this->cache->delete($this->options['cache_key'])) {
throw new CacheException('Could not delete the key in the cache. Do you have permission?');
}
if ($e instanceof TokenExpiredException || $e instanceof TokenInvalidException) {
if ($this->options['token_refresh']) {
return $this->{$method}($resource, $request, $headers, $returnType);
}
}
throw $e;
}
}
/**
* @param string $txid
* @param int $vout
*/
public function remove($txid, $vout)
{
$this->cache->delete($this->getInternalIndex($txid, $vout));
}
public function delete($storageName, $key)
{
$key = $this->flattenKey($storageName, $key);
$this->cache->delete($key);
}
