public function retrieve($user)
{
$data = json_decode($this->storage->get('usr.' . $user->getKey() . '.lastSeen'));
// Make the stored date into Carbon object
if ($data) {
$data->date = Carbon::createFromFormat('Y-m-d H:i:s', $data->date);
return $data;
}
$data = json_decode('{"date":""}');
$data->date = Carbon::now();
return $data;
}
public function dashboard()
{
$messages = Redis::lrange('messages', 0, -1);
$messages = $messages ? $messages : [];
$tasks = Auth::user()->tasks()->get();
return view('dashboard', compact('messages', 'tasks'));
}
public function create($object_id)
{
$newComment = Comment::create(['object_id' => $object_id, 'user_id' => Auth::id(), 'comment' => Input::get('comment.comment'), 'parent' => Input::get('comment.parent'), 'depth' => 0]);
$comment = Comment::where('comment_id', $newComment->comment_id)->with('user')->first();
Redis::sadd('objects:toReindex', $object_id);
return response()->json($comment);
}
/**
*
*
*/
public function welcome()
{
$topic = new \App\Topic();
$topics = $topic->recentlyCreated();
$categories = new \App\Categories();
$categories = $categories->all();
//If user then check if they have confirmed email and username
if (Auth::user()) {
//if email is not confirm
if (Auth::user()->confirmed == 0) {
return redirect('/verification');
}
//if displayname is not set
if (empty(Auth::user()->displayname)) {
return redirect()->action('ProfileController@createName');
}
}
$storage = Redis::connection();
$mostView = $storage->zRevRange('postViews', 0, 1);
foreach ($mostView as $value) {
$id = str_replace('post:', '', $value);
// echo "<br> post". $id;
}
return view('welcome', compact('topics', 'categories'));
}
/**
* Execute the console command.
*
* @return mixed
*/
public function handle()
{
$a = Redis::command("KEYS", ['q*']);
foreach ($a as $cmd) {
$q = $cmd;
$t = Redis::command('TYPE', [$q]);
if ($t == 'zset') {
$count = Redis::command('ZCARD', [$q]);
} else {
if ($t == 'list') {
$count = Redis::command('LLEN', [$q]);
} else {
$count = 'x';
}
}
$this->info($cmd . ' ' . $t . ' ' . $count);
}
if (count($a)) {
$abort = $this->option('force');
if ($abort || $this->ask("Abort queues (y/N)?", 'N') == 'y') {
$this->comment("Aborting...");
foreach ($a as $cmd) {
Redis::command("DEL", [$cmd]);
}
$this->comment("Aborted");
}
} else {
$this->info('Queues not found');
}
}
public function checkRedis($config)
{
$startTime = $this->slog_time();
$checkResult['checkType'] = 'Check Redis';
$checkResult['checkService'] = 'Connect Redis';
$checkResult['type'] = 'Redis';
$checkResult['url'] = Config::get('database.redis.' . $config['redis'] . '.host');
try {
$redis = Redis::connection();
$ping = $redis->ping();
if (empty($redis)) {
$checkResult['setStatus'] = false;
$checkResult['setMessage'] = 'fail';
$checkResult['setTime'] = $this->elog_time($startTime);
} else {
$checkResult['setStatus'] = true;
$checkResult['setMessage'] = 'Success';
$checkResult['setTime'] = $this->elog_time($startTime);
}
} catch (\Exception $e) {
$checkResult['setStatus'] = false;
$checkResult['setMessage'] = $e->getMessage();
$checkResult['setTime'] = $this->elog_time($startTime);
}
return $checkResult;
}
/**
* Execute the console command.
*
* @return mixed
*/
public function handle()
{
// Fetch objects and delete redis sets
$objects = Object::whereIn('object_id', Redis::smembers('objects:toReindex'))->get();
$collections = Collection::whereIn('collection_id', Redis::smembers('collections:toReindex'))->get();
$dataViews = DataView::whereIn('dataview_id', Redis::smembers('dataviews:toReindex'))->get();
Redis::del(['objects:toReindex', 'collections:toReindex', 'dataviews:toReindex']);
// Map to return searchable interfaces and reindex
if ($objects->count() > 0) {
foreach ($objects as $object) {
$searchableObjects[] = $object->search();
}
Search::bulkReindex($searchableObjects);
}
if ($collections->count() > 0) {
foreach ($collections as $collection) {
$searchableCollections[] = $collection->search();
}
Search::bulkReindex($searchableCollections);
}
if ($dataViews->count() > 0) {
foreach ($dataViews as $dataView) {
$searchableDataViews[] = $dataView->search();
}
Search::bulkReindex($searchableDataViews);
}
}
private function registerCache()
{
$this->app->singleton(Cache::class, function ($app) {
$config = $this->laravelToDoctrineConfigMapper();
$cacheClass = "\\Doctrine\\Common\\Cache\\" . $config['type'];
if (!class_exists($cacheClass)) {
throw new Exception\ImplementationNotFound($cacheClass);
}
switch ($config['type']) {
case 'ArrayCache':
$cache = new $cacheClass();
break;
case 'FilesystemCache':
$cache = new $cacheClass($config['dir']);
break;
case 'MemcacheCache':
$cache = new $cacheClass();
$cache->setMemcache($this->setupMemcache($config));
break;
case "PredisCache":
$cache = new $cacheClass(Redis::connection($config['connection']));
break;
}
if (Config::has('d2bcache.namespace')) {
$cache->setNamespace(Config::get('d2bcache.namespace'));
}
return $cache;
});
}
/**
* Execute the console command.
*
* @return mixed
*/
public function handle()
{
$youtube = new Client();
$searchResponse = json_decode($youtube->get('https://www.googleapis.com/youtube/v3/search?part=snippet&channelId=' . $this->channelID . '&eventType=live&type=video&key=' . Config::get('services.youtube.key'))->getBody());
$isLive = $searchResponse->pageInfo->totalResults != 0;
// Determine the total number of viewers
if ($isLive) {
$videoResponse = json_decode($youtube->get('https://www.googleapis.com/youtube/v3/videos?part=liveStreamingDetails&id=' . $searchResponse->items[0]->id->videoId . '&key=' . Config::get('services.youtube.key'))->getBody());
$viewers = $videoResponse->items[0]->liveStreamingDetails->concurrentViewers;
} else {
$viewers = 0;
}
// If the livestream is active now, and wasn't before, or vice versa, send an event
if ($isLive && (Redis::hget('webcast', 'isLive') == 'false' || !Redis::hexists('webcast', 'isLive'))) {
// Grab all the relevant SpaceX youtube Livestreams, and create an event
$videos = $this->getMultipleYoutubeLivestreams($videoId);
// $searchResponse->items[0]->id->videoId
event(new WebcastStartedEvent($videos));
} elseif (!$isLive && Redis::hget('webcast', 'isLive') == 'true') {
// turn off the spacex webcast
event(new WebcastEndedEvent("spacex", false));
}
// Set the Redis properties
Redis::hmset('webcast', 'isLive', $isLive === true ? 'true' : 'false', 'viewers', $viewers);
// Add to Database if livestream is active
if ($isLive) {
WebcastStatus::create(['viewers' => $viewers]);
}
}
public function __construct()
{
$this->redis = Redis::connection();
if (!$this->redis) {
throw new \Exception("redis connection error", 80000);
}
}
public function end()
{
if ($this->qid) {
$queueJob = QueueJob::get($this->qid);
$queueJob = $queueJob->finish();
Redis::LSET(config('queue-managers.name'), $queueJob->qid, $queueJob->toJson());
}
}
public function __construct($arrInfo)
{
$this->arr = $arrInfo;
// $this->redis = new Redis();
$this->redis = Redis::connection('default');
// $this->redis->connect('127.0.0.1',6379);
}
public function setDescription()
{
//Redisアクセス
$redisData = Redis::connection();
$setData[] = array('parking_space_id' => '1', 'description_id' => '1', 'description_type' => '3', 'title_text' => '夜はお静かに');
$setJsonData = json_encode($setData, JSON_PRETTY_PRINT | JSON_UNESCAPED_UNICODE);
//$redisData->delete('00000001');
$redisData->hSet('parking_description_1', '1', $setJsonData);
}
/**
* Remove the specified resource from storage.
*
* @param int $id
* @return Response
*/
public function destroy($motto)
{
$result = Redis::command('SREM', ['mottos', $motto]);
if ($result) {
return redirect('/admin/motto')->with('message', '删除博客签名成功.');
} else {
return redirect('/admin/motto')->with('message', '添加博客签名失败.');
}
}
public function issue($type, UserModel $destinationUser, ProjectModel $projectModel, ActivityModel $activityModel, $corpus)
{
$notification = NotificationModel::generate($type, $destinationUser, $projectModel, $activityModel, $corpus);
$not = $this->notificationRepository->save($notification);
$redis = Redis::connection();
$transformer = \App::make(NotificationTransformer::class);
$redis->publish($destinationUser->hash, json_encode($transformer->transform($notification)));
return $not;
}
/**
* Execute the console command.
*
* @return void
*/
public function fire()
{
$this->infoStart('Getting official skin list...');
$skins = $this->getOfficialSkinList();
$this->infoFinish('Getting official skin done');
$this->infoStart('Resolving skin ids to items...');
$skins = $this->resolveSkinsToItems($skins);
$this->infoFinish('Resolving skin ids to items done');
Redis::set(self::$key, serialize($skins));
}
public function sendMessage(Request $request)
{
try {
$redis = Redis::connection();
$redis->publish('message', $request->get('message'));
return redirect('writemessage');
} catch (Exception $exc) {
echo $exc->getTraceAsString();
}
}
/**
* Send the response after the user was authenticated.
*
* @param \Illuminate\Http\Request $request
* @param bool $throttles
* @return \Illuminate\Http\Response
*/
protected function handleUserWasAuthenticated(Request $request, $throttles)
{
if ($throttles) {
$this->clearLoginAttempts($request);
}
if (method_exists($this, 'authenticated')) {
return $this->authenticated($request, Auth::user());
}
Redis::publish('connected', Auth::user());
return redirect()->intended($this->redirectPath());
}
/**
* Extend broadcast manager
*/
public function boot()
{
//publish
$this->publishes([sprintf('%1$s%2$s..%2$s%3$s%2$s%3$s.php', __DIR__, DIRECTORY_SEPARATOR, Constants\Common::TAG_CONFIG) => base_path(sprintf('%s%s%s.php', Constants\Common::TAG_CONFIG, DIRECTORY_SEPARATOR, Constants\Common::T_NAMESPACE))], Constants\Common::TAG_CONFIG);
//extend broadcast manager
app(BroadcastManager::class)->extend('socket.io', function ($app) {
$config = $app['config'];
//init socket.io broadcaster
return new SocketIOBroadcaster(new Emitter(Redis::connection($config->get('broadcasting.connections.socket\\.io.redis.connection', 'default')), $config->get(sprintf('%s.emitter.prefix', Constants\Common::T_NAMESPACE), Constants\Common::EMITTER_PREFIX)));
});
}
/**
* Execute the console command.
*
* @return void
*/
public function fire()
{
$this->infoStart('Parsing EU leaderboard...');
$eu_rankings = $this->parseLeaderboard('eu');
$this->infoFinish('Done parsing!');
$this->infoStart('Parsing NA leaderboard...');
$na_rankings = $this->parseLeaderboard('na');
$this->infoFinish('Done parsing!');
Redis::set(self::$key, serialize(['eu' => $eu_rankings, 'na' => $na_rankings]));
// Trigger an event for post-processor to hook into
Event::fire(new PvpLeaderboardUpdated());
}
/**
* Execute the job.
*
* @return void
*/
public function handle()
{
// Rerender content
$templatedOutput = view('templates.livethreadcontents')->with(['updates' => collect(Redis::lrange('live:updates', 0, -1))->reverse()->map(function ($update) {
return json_decode($update);
})])->render();
// Connect to Reddit
$reddit = new Reddit(Config::get('services.reddit.username'), Config::get('services.reddit.password'), Config::get('services.reddit.id'), Config::get('services.reddit.secret'));
$reddit->setUserAgent('ElongatedMuskrat bot by u/EchoLogic. Runs various /r/SpaceX-related tasks.');
// Update Thread
$reddit->thing(Redis::hget('live:reddit', 'thing'))->edit($templatedOutput);
}
/**
* @param int $start
* @param int $end
* @param string $view
*
* @return \Illuminate\View\View
*/
protected function linkView($start, $end, $view)
{
$links = [];
for ($i = $start; $i <= $end; $i += 1) {
$hash = 'link:' . $i;
$title = Redis::command('hget', [$hash, 'title']);
if ($title !== null) {
$links[$i] = $title;
}
}
return view($view, ['links' => $links]);
}
private function clear_articels_cache()
{
$pages = Redis::command('lrange', ['welcome:articles:pages', 0, -1]);
foreach ($pages as $cache_key) {
if (Cache::has($cache_key)) {
Cache::forget($cache_key);
}
}
Redis::command('del', ['welcome:articles:pages']);
Cache::forget('self:rss');
Cache::forget('self:archive');
Cache::forget('self::categorie');
}
public function getStatus()
{
// Check if the redis values exist
try {
//if (Redis::exists('webcast:isLive') == 1 && Redis::exists('webcast:viewers') == 1) {
return response()->json(Redis::hgetall('webcast'));
//} else {
// return response()->json(array('isLive' => null, 'viewers' => null));
//}
} catch (Predis\Connection\ConnectionException $e) {
return response()->json(['isLive' => null, 'viewers' => null]);
}
}
public function authenticate(Request $request)
{
\R::setup('mysql:host=localhost;dbname=gazingle', 'root', '');
$redis = Redis::connection();
$user = \R::getRow('select * from users where email = "' . $request->email . '"');
//return $user;
if ($request->password === \Crypt::decrypt($user['password'])) {
\Auth::loginUsingId($user['id']);
$redis->set(\Crypt::encrypt($request->email), $user['id']);
return $redis->get($request->email);
}
return response('Unauthorized.', 401);
}
/**
* Constructs a human readable relative timestamp relative to when the event is being counted down to.
* If a launch is paused, we will instead show a timestamp which reads "Paused".
*
* @internal
* @return string
*/
private function constructTimestamp()
{
// Check if paused
if (!Redis::hget('live:countdown', 'isPaused')) {
$countdownTo = Carbon::createFromFormat('Y-m-d H:i:s', Redis::hget('live:countdown', 'to'));
$diffInSeconds = $this->createdAt->diffInSeconds($countdownTo, false);
$absDiffInSeconds = abs($diffInSeconds);
$sign = $diffInSeconds < 0 ? '+' : '-';
if ($absDiffInSeconds > 86400) {
$days = floor($absDiffInSeconds / 86400);
$hours = intval(round($absDiffInSeconds % 86400 / 3600));
$timestamp = "T{$sign}{$days}d";
if ($hours !== 0) {
if ($hours === 60) {
$days++;
$timestamp = "T{$sign}{$days}d";
} else {
$timestamp .= " {$hours}h";
}
}
} elseif ($absDiffInSeconds > 3600) {
$hours = floor($absDiffInSeconds / 3600);
$minutes = intval(round($absDiffInSeconds % 3600 / 60));
$timestamp = "T{$sign}{$hours}h";
if ($minutes !== 0) {
if ($minutes === 60) {
$hours++;
$timestamp = "T{$sign}{$hours}d";
} else {
$timestamp .= " {$minutes}m";
}
}
} elseif ($absDiffInSeconds > 60) {
$minutes = floor($absDiffInSeconds / 60);
$seconds = intval(round($absDiffInSeconds % 60));
$timestamp = "T{$sign}{$minutes}m";
if ($seconds !== 0) {
if ($seconds === 60) {
$minutes++;
$timestamp = "T{$sign}{$minutes}m";
} else {
$timestamp .= " {$seconds}s";
}
}
} else {
$timestamp = "T{$sign}{$absDiffInSeconds}s";
}
return $timestamp;
}
return 'Paused';
}
public static function boot()
{
parent::boot();
Project::updating(function ($project) {
$msg = "<a href='/projects/{$project->id}'>The project: {$project->name} was updated.</a>";
Redis::lpush('messages', $msg);
Redis::publish('new-message', $msg);
});
Project::creating(function ($project) {
$msg = "<a href='/projects/{$project->id}'>The project: {$project->name} was created.</a>";
Redis::lpush('messages', $msg);
Redis::publish('new-message', $msg);
});
}
/**
* Function remove all redis data for specified language
*
* @param $language
*/
public function clear($language)
{
if (Redis::del(Key::posts($language))) {
$this->info('Remove all entries for key ' . Key::posts($language));
}
if (Redis::del(Key::tags($language))) {
$this->info('Remove all entries for key ' . Key::tags($language));
}
foreach (Redis::keys(Key::post('*', $language)) as $key) {
if (Redis::del($key)) {
$this->info('Remove all entries for keys ' . $key);
}
}
}
public function byTag($tag)
{
$posts = Redis::smembers(Key::tags($tag));
foreach ($posts as &$post) {
$post = $this->loader->load($post);
}
uasort($posts, function ($a, $b) {
return $a['published'] > $b['published'] ? -1 : 1;
});
$total = count($posts);
$amount = config('blog.posts_on_page');
$current = Request::get('page') ?: 1;
$start = $amount * $current - $amount;
return (new LengthAwarePaginator(array_slice($posts, $start, $amount), $total, $amount, $current))->setPath($tag);
}
/**
* Create a new event instance.
*
* @param $isActive
* @param null $videoId
*/
public function __construct($videos)
{
foreach ($videos as $videoName => $videoId) {
// Update the Redis parameters
$spacexLivestream = json_decode(Redis::hget('live:streams', $videoName));
if ($spacexLivestream === null) {
$spacexLivestream = new \stdClass();
}
$spacexLivestream->isActive = true;
$spacexLivestream->isAvailable = true;
$spacexLivestream->youtubeVideoId = $videoId;
Redis::hset('live:streams', $videoName, json_encode($spacexLivestream));
}
$this->videos = $videos;
}
