BeyondCode\LaravelWebSockets\Statistics\Stores\DatabaseStore

Complexity

Total Complexity

5

Size/Duplication

Total Lines	108
Duplicated Lines	0 %

Coupling/Cohesion

Components	1
Dependencies	2

Importance

Changes

0

5 Methods

Rating	Name	Duplication	Size	Complexity
A	store()	0	4	1
A	delete()	0	8	1
A	getRawRecords()	0	9	1
A	getRecords()	0	16	1
A	getForGraph()	0	21	1

<?php

namespace BeyondCode\LaravelWebSockets\Statistics\Stores;

use BeyondCode\LaravelWebSockets\Contracts\StatisticsStore;
use Carbon\Carbon;
use Illuminate\Database\Eloquent\Model;

class DatabaseStore implements StatisticsStore
{
    /**
     * The model that will interact with the database.
     *
     * @var string
     */
    protected static $model = \BeyondCode\LaravelWebSockets\Models\WebSocketsStatisticsEntry::class;

    /**
     * Store a new record in the database and return
     * the created instance.
     *
     * @param  array  $data
     * @return mixed
     */
    public static function store(array $data)
    {
        return static::$model::create($data);

The method create cannot be called on static::$model (of type string).

    }

    /**
     * Delete records older than the given moment,
     * for a specific app id (if given), returning
     * the amount of deleted records.
     *
     * @param  \Carbon\Carbon  $moment
     * @param  string|int|null  $appId
     * @return int
     */
    public static function delete(Carbon $moment, $appId = null): int
    {
        return static::$model::where('created_at', '<', $moment->toDateTimeString())

The method where cannot be called on static::$model (of type string).

            ->when(! is_null($appId), function ($query) use ($appId) {
                return $query->whereAppId($appId);
            })
            ->delete();
    }

    /**
     * Get the query result as eloquent collection.
     *
     * @param  callable  $processQuery
     * @return \Illuminate\Support\Collection
     */
    public function getRawRecords(callable $processQuery = null)
    {
        return static::$model::query()

The method query cannot be called on static::$model (of type string).

            ->when(! is_null($processQuery), function ($query) use ($processQuery) {
                return call_user_func($processQuery, $query);
            }, function ($query) {
                return $query->latest()->limit(120);
            })->get();
    }

    /**
     * Get the results for a specific query.
     *
     * @param  callable  $processQuery
     * @param  callable  $processCollection
     * @return array
     */
    public function getRecords(callable $processQuery = null, callable $processCollection = null): array
    {
        return $this->getRawRecords($processQuery)
            ->when(! is_null($processCollection), function ($collection) use ($processCollection) {
                return call_user_func($processCollection, $collection);
            })
            ->map(function (Model $statistic) {
                return [
                    'timestamp' => (string) $statistic->created_at,
                    'peak_connections_count' => $statistic->peak_connections_count,
                    'websocket_messages_count' => $statistic->websocket_messages_count,
                    'api_messages_count' => $statistic->api_messages_count,
                ];
            })
            ->toArray();
    }

    /**
     * Get the results for a specific query into a
     * format that is easily to read for graphs.
     *
     * @param  callable  $processQuery
     * @return array
     */
    public function getForGraph(callable $processQuery = null): array
    {
        $statistics = collect(
            $this->getRecords($processQuery)
        );

        return [
            'peak_connections' => [
                'x' => $statistics->pluck('timestamp')->toArray(),
                'y' => $statistics->pluck('peak_connections_count')->toArray(),
            ],
            'websocket_messages_count' => [
                'x' => $statistics->pluck('timestamp')->toArray(),
                'y' => $statistics->pluck('websocket_messages_count')->toArray(),
            ],
            'api_messages_count' => [
                'x' => $statistics->pluck('timestamp')->toArray(),
                'y' => $statistics->pluck('api_messages_count')->toArray(),
            ],
        ];
    }
}