/**
* {@inheritdoc}
*/
protected function doSave($id, $data, $lifeTime = false)
{
if (!$lifeTime) {
return $this->cache->forever($id, $data);
}
return $this->cache->put($id, $data, $lifeTime);
}
public function check($value)
{
$result = false;
if ($this->store->has('captcha')) {
$captchaStore = $this->store->get('captcha');
$result = $captchaStore->check($value);
$this->store->forever('captcha', $captchaStore);
}
return $result;
}
private function recountForums()
{
$this->info('Recounting forum counters...');
// We're calling the model directly to avoid caching issues
$forums = Forum::all();
foreach ($forums as $forum) {
// We need the topics later to calculate the post number and the last post
$topics = Topic::where('forum_id', '=', $forum->id)->orderBy('created_at', 'desc');
$forum->num_topics = $topics->count();
$numPosts = 0;
$lastPost = null;
$lastPostUser = null;
foreach ($topics->get() as $topic) {
$numPosts += $topic->num_posts;
// We can simply override this variable all the time.
// The topics are sorted so the last time we override this we have our last post
$lastPost = $topic->last_post_id;
$lastPostUser = $topic->lastPost->user_id;
}
$forum->num_posts = $numPosts;
$forum->last_post_id = $lastPost;
$forum->last_post_user_id = $lastPostUser;
$forum->save();
}
// Override our old cache to populate our new numbers
$this->cache->forever('forums.all', $forums);
// We could also recache this cache but the recount tool is already busy
// so probably better to leave it to the first user
$this->cache->forget('forums.index_tree');
$this->info('Done' . PHP_EOL);
}
/**
* {@inheritdoc}
*/
public function save(CacheItemInterface $item)
{
$expiresAt = $this->getExpiresAt($item);
if (!$expiresAt) {
try {
$this->repository->forever($item->getKey(), serialize($item->get()));
} catch (Exception $exception) {
return false;
}
return true;
}
$now = new DateTimeImmutable('now', $expiresAt->getTimezone());
$seconds = $expiresAt->getTimestamp() - $now->getTimestamp();
$minutes = (int) floor($seconds / 60.0);
if ($minutes <= 0) {
$this->repository->forget($item->getKey());
return false;
}
try {
$this->repository->put($item->getKey(), serialize($item->get()), $minutes);
} catch (Exception $exception) {
return false;
}
return true;
}
/**
* Get the forum tree for the index, consisting of root forums (categories), and one level of descendants.
*
* @param bool $checkPermissions
*
* @return mixed
*/
public function getIndexTree($checkPermissions = true)
{
if (($forums = $this->cache->get('forums.index_tree')) == null) {
$forums = $this->decoratedRepository->getIndexTree(false);
$this->cache->forever('forums.index_tree', $forums);
}
if ($checkPermissions) {
$forums = $this->filterUnviewableForums($forums);
}
return $forums;
}
public function handle(RateFetcher $source, Cache $cache)
{
$rates = $source->getUsdRates($this->date);
if (!count($rates)) {
throw new ForexException('received empty array of rates');
}
$cacheKey = $this->date ? $this->date->format('Y-m-d') : 'live';
// save rates for two hours to main cache
$cache->put(ForexService::RATE_CACHE_KEY_PREFIX . $cacheKey, $rates, 120);
// save rates indefinitely for backup cache
$cache->forever(ForexService::BACKUP_CACHE_KEY_PREFIX . $cacheKey, $rates);
}
/**
* Execute the console command.
*
* @param Repository $cache
*
* @return mixed
*/
public function handle(Repository $cache)
{
$iterations_count = $this->argument('iterations') ?: 1;
/** @var BaseBot $bot */
$bot = app('Bot');
while ($iterations_count--) {
$updatesChunk = $bot->getTelegram()->getUpdates($cache->get(self::CACHE_KEY) + 1, null, 3);
foreach ($updatesChunk as $update) {
$bot->handle($update);
$cache->forever(self::CACHE_KEY, $update->update_id);
}
}
}
/**
* Return the total users and logged users.
*
* @return array
*/
public function refreshUsersStatus()
{
$rtm = $this->slackRtm->start();
$totals = $this->getEmptyStatus();
foreach ($rtm['users'] as $user) {
if ($this->isRealUser($user)) {
$totals['total']++;
if ($this->isActiveUser($user)) {
$totals['active']++;
}
}
}
$this->cache->forever(self::SLACK_TOTALS_KEY, $totals);
return $totals;
}
public function syncRef($ref, $type, Closure $progress = null)
{
$this->fire('git.syncer.start', [$ref, $type]);
$owner = $this->setting('owner');
$repo = $this->setting('repository');
$docPath = $this->setting('sync.paths.docs');
$menuPath = $this->setting('sync.paths.menu');
$indexPath = $this->setting('sync.paths.index');
$remote = $this->client($this->setting('remote'));
$rfs = $remote->getFilesystem($repo, $owner, $ref);
$files = $rfs->allFiles($this->setting('sync.paths.docs'));
if (!$rfs->exists($indexPath)) {
return $this->log('error', 'syncRef could not find the index file', [$indexPath]);
}
if (!$rfs->exists($menuPath)) {
return $this->log('error', 'syncRef could not find the menu file', [$indexPath]);
}
$destinationDir = $this->project->path($ref);
$menuContent = $rfs->get($this->setting('sync.paths.menu'));
//#base64_decode($menu[ 'content' ]);
$menuArray = Yaml::parse($menuContent);
$unfilteredPages = [];
$this->extractDocumentsFromMenu($menuArray['menu'], $unfilteredPages);
$this->ensureDirectory($destinationDir);
$files = $rfs->allFiles($this->setting('sync.paths.docs'));
$total = count($files);
$syncer = $this;
foreach ($files as $current => $file) {
$localPath = Path::makeRelative($file, $this->setting('sync.paths.docs'));
if ($progress instanceof Closure) {
#$file = new \SplFileInfo(path_join($this->project->getPath(), $destinationDir, $localPath));
$this->project->getContainer()->call($progress, compact('current', 'total', 'file', 'files', 'syncer'));
}
$localPath = Path::join($destinationDir, $localPath);
$dir = Path::getDirectory($localPath);
$this->ensureDirectory($dir);
$this->files->put($localPath, $rfs->get($file));
}
// index.md resolving
$indexFile = $rfs->get($this->setting('sync.paths.index'));
$this->files->put(Path::join($destinationDir, 'index.md'), $indexFile);
if ($type === 'branch') {
$branch = $remote->getBranch($this->setting('repository'), $ref, $this->setting('owner'));
$this->cache->forever(md5($this->project->getName() . $branch['name']), $branch['sha']);
}
$this->fire('git.syncer.finish', [$ref, $type]);
}
/**
* {@inheritdoc}
*/
public function save(CacheItemInterface $item)
{
$expiresInMinutes = null;
if ($item instanceof CacheItem) {
$expiresInMinutes = $item->getTTL();
}
try {
if (is_null($expiresInMinutes)) {
$this->repository->forever($item->getKey(), serialize($item->get()));
} else {
$this->repository->put($item->getKey(), serialize($item->get()), $expiresInMinutes);
}
} catch (Exception $exception) {
return false;
}
return true;
}
public function syncRef($ref, $type)
{
$this->project->getFactory()->log('info', 'codex.hooks.git.syncer.sync.start', compact('ref', 'type'));
$this->runHook('git:syncer:start', [$this, $ref, $type]);
$owner = $this->setting('owner');
$repo = $this->setting('repository');
$docPath = $this->setting('sync.paths.docs');
$indexPath = $this->setting('sync.paths.docs');
$remote = $this->client($this->setting('remote'));
$rfs = $remote->getFilesystem($repo, $owner, $ref);
$files = $rfs->allFiles($this->setting('sync.paths.docs'));
$indexExists = $rfs->exists(Path::join($this->setting('sync.paths.docs'), 'index.md'));
$menuExists = $rfs->exists(Path::join($this->setting('sync.paths.docs'), 'menu.yml'));
$a = 'b';
if (!$indexExists || !$menuExists) {
return;
}
$destinationDir = Path::join($this->project->getPath(), $ref);
$menuContent = $rfs->get($this->setting('sync.paths.menu'));
//#base64_decode($menu[ 'content' ]);
$menuArray = Yaml::parse($menuContent);
$unfilteredPages = [];
$this->extractDocumentsFromMenu($menuArray['menu'], $unfilteredPages);
$this->ensureDirectory($destinationDir);
foreach ($rfs->allFiles($this->setting('sync.paths.docs')) as $path) {
$localPath = Path::makeRelative($path, $this->setting('sync.paths.docs'));
$localPath = Path::join($destinationDir, $localPath);
$dir = Path::getDirectory($localPath);
$this->ensureDirectory($dir);
$this->files->put($localPath, $rfs->get($path));
}
if ($type === 'branch') {
$branch = $remote->getBranch($this->setting('repository'), $ref, $this->setting('owner'));
$this->cache->forever(md5($this->project->getName() . $branch['name']), $branch['sha']);
}
$this->runHook('git:syncer:done', [$this, $ref, $type]);
$this->project->getFactory()->log('info', 'codex.hooks.git.syncer.sync.end', compact('ref', 'type'));
}
/**
* @param Role $role
* @param string $permission
* @param string|null $content
* @param int|null $contentID
* @param NEVER|NO|YES $value
*/
private function putCache(Role $role, $permission, $content, $contentID, $value)
{
$this->cache->forever("permission.{$role->role_slug}.{$permission}.{$content}.{$contentID}", $value);
}
/**
* Cache a value forever
* @param $key
* @param $value
*/
public function cacheForever($key, $value)
{
$this->cache->forever($this->cachePrefix($key), $value);
}
/**
* Store an item in the cache indefinitely.
*
* @param string $key
* @param mixed $value
*/
public function forever($key, $value)
{
$this->cache->forever($key, $value);
}
public function syncRef($ref, $type)
{
$content = new GitSyncContent($this->setting('owner'), $this->setting('repository'), $this->github);
$hasDocs = $content->exists($this->setting('sync.paths.docs'), $ref);
if (!$hasDocs) {
return;
}
$destinationDir = Path::join($this->project->getPath(), $ref);
$menu = $content->show($this->setting('sync.paths.menu'), $ref);
$menuContent = base64_decode($menu['content']);
$menuArray = Yaml::parse($menuContent);
$unfilteredPages = [];
$this->extractDocumentsFromMenu($menuArray['menu'], $unfilteredPages);
$filteredPages = [];
# filter out pages that link to external sites
foreach ($unfilteredPages as $page) {
if (Str::startsWith($page, 'http', true) || Str::startsWith($page, '//', true) || Str::startsWith($page, 'git', true)) {
continue;
}
if (!in_array($page, $filteredPages, true)) {
$filteredPages[] = $page;
}
}
# get all pages their content and save to local
foreach ($filteredPages as $pagePath) {
$path = Path::join($this->setting('sync.paths.docs'), $pagePath . '.md');
# check if page exists on remote
$exists = $content->exists($path, $ref);
if (!$exists) {
continue;
}
# the raw github page content response
$pageRaw = $content->show('/' . $path, $ref);
# transform remote directory path to local directory path
$dir = Str::remove($pageRaw['path'], $this->setting('sync.paths.docs'));
$dir = Str::remove($dir, $pageRaw['name']);
$dir = Path::canonicalize(Path::join($destinationDir, $dir));
if (!$this->files->exists($dir)) {
$this->files->makeDirectory($dir);
}
# raw github page to utf8 and save it to local
$this->files->put(Path::join($dir, $pageRaw['name']), base64_decode($pageRaw['content']));
}
# save the menu to local
$this->files->put(Path::join($destinationDir, 'menu.yml'), $menuContent);
# if enabled, Get phpdoc structure and save it
if ($this->setting('phpdoc')) {
$hasStructure = $content->exists($this->setting('paths.phpdoc'), $ref);
if ($hasStructure) {
$structure = $content->show($this->setting('paths.phpdoc'), $ref);
$structureXml = base64_decode($structure['content']);
$destination = Path::join($destinationDir, 'structure.xml');
$destinationDir = Path::getDirectory($destination);
if (!$this->files->exists($destinationDir)) {
$this->files->makeDirectory($destinationDir);
}
$this->files->put($destination, $structureXml);
}
}
# set cache sha for branches, not for tags (obviously)
if ($type === 'branch') {
$branchData = $this->github->repositories()->branches($this->setting('owner'), $this->setting('repository'), $ref);
$this->cache->forever(md5($this->project->getName() . $branchData['name']), $branchData['commit']['sha']);
}
}
/**
* Execute the job.
*
* @return void
*/
public function handle(Cache $cache, FlagHelper $flag)
{
$cache->forever($flag->getFlagName($this->connectionName, $this->queueName), time());
}
