Skip to content

Open-source social media scheduler built for AI agents and the teams behind them. Create, schedule and publish posts to every network through MCP or the REST API, or write them yourself in a composer your team will love.

4.1 KB
Raw Blame
<?php

declare(strict_types=1);

namespace App\Models;

use App\Enums\Analytics\FacebookMediaKey;
use App\Enums\Analytics\PublicationAvailability;
use App\Enums\Analytics\PublicationContentType;
use App\Enums\Analytics\PublicationOrigin;
use App\Enums\SocialAccount\Platform;
use App\Observers\AnalyticsPublicationObserver;
use Database\Factories\AnalyticsPublicationFactory;
use Illuminate\Database\Eloquent\Attributes\ObservedBy;
use Illuminate\Database\Eloquent\Builder;
use Illuminate\Database\Eloquent\Concerns\HasUuids;
use Illuminate\Database\Eloquent\Factories\HasFactory;
use Illuminate\Database\Eloquent\Model;
use Illuminate\Database\Eloquent\Relations\BelongsTo;
use Illuminate\Database\Eloquent\Relations\HasMany;

#[ObservedBy([AnalyticsPublicationObserver::class])]
class AnalyticsPublication extends Model
{
    /** @use HasFactory<AnalyticsPublicationFactory> */
    use HasFactory, HasUuids;

    protected $fillable = [
        'workspace_id',
        'social_account_id',
        'social_account_key',
        'post_id',
        'post_dismissed_at',
        'network',
        'platform_user_id',
        'platform',
        'remote_id',
        'provider_published_at',
        'origin',
        'content_type',
        'availability',
        'metric_failures',
        'provider_content_type',
        'permalink',
        'excerpt',
        'preview_metadata',
        'account_display_name',
        'account_username',
        'account_avatar_url',
        'first_seen_at',
        'last_seen_at',
        'provider_synced_at',
        'provider_metadata',
    ];

    protected function casts(): array
    {
        return [
            'platform' => Platform::class,
            'post_dismissed_at' => 'immutable_datetime',
            'provider_published_at' => 'immutable_datetime',
            'origin' => PublicationOrigin::class,
            'content_type' => PublicationContentType::class,
            'availability' => PublicationAvailability::class,
            'metric_failures' => 'integer',
            'preview_metadata' => 'array',
            'first_seen_at' => 'immutable_datetime',
            'last_seen_at' => 'immutable_datetime',
            'provider_synced_at' => 'immutable_datetime',
            'provider_metadata' => 'array',
        ];
    }

    public function workspace(): BelongsTo
    {
        return $this->belongsTo(Workspace::class);
    }

    public function socialAccount(): BelongsTo
    {
        return $this->belongsTo(SocialAccount::class);
    }

    public function post(): BelongsTo
    {
        return $this->belongsTo(Post::class);
    }

    public function dailySnapshots(): HasMany
    {
        return $this->hasMany(AnalyticsPublicationDailySnapshot::class, 'publication_id');
    }

    public function scopeAvailable(Builder $query): Builder
    {
        return $query->where('availability', PublicationAvailability::Available);
    }

    /**
     * Carrying one of `$mediaIds` as its Facebook video or photo; an empty list
     * matches nothing.
     *
     * @param  list<string>  $mediaIds
     */
    public function scopeCarryingFacebookMedia(Builder $query, array $mediaIds): Builder
    {
        return $query->where(function (Builder $carrying) use ($mediaIds): void {
            foreach (FacebookMediaKey::cases() as $key) {
                $carrying->orWhereIn("provider_metadata->{$key->value}", $mediaIds);
            }
        });
    }

    /**
     * The Facebook video or photo this publication carries, which TryPost may
     * have saved as its post's id.
     *
     * @return list<string>
     */
    public function facebookMediaIds(): array
    {
        if ($this->platform !== Platform::Facebook) {
            return [];
        }

        return collect(FacebookMediaKey::cases())
            ->map(fn (FacebookMediaKey $key): mixed => data_get($this->provider_metadata, $key->value))
            ->filter(fn (mixed $id): bool => is_string($id) && filled($id))
            ->values()
            ->all();
    }

    public function isLinkable(): bool
    {
        return $this->availability === PublicationAvailability::Available
            && blank($this->post_id)
            && blank($this->post_dismissed_at);
    }
}