mirror of
https://github.com/usetrmnl/byos_laravel.git
synced 2026-01-13 15:07:49 +00:00
567 lines
22 KiB
PHP
567 lines
22 KiB
PHP
<?php
|
|
|
|
namespace App\Models;
|
|
|
|
use App\Liquid\FileSystems\InlineTemplatesFileSystem;
|
|
use App\Liquid\Filters\Data;
|
|
use App\Liquid\Filters\Date;
|
|
use App\Liquid\Filters\Localization;
|
|
use App\Liquid\Filters\Numbers;
|
|
use App\Liquid\Filters\StandardFilters;
|
|
use App\Liquid\Filters\StringMarkup;
|
|
use App\Liquid\Filters\Uniqueness;
|
|
use App\Liquid\Tags\TemplateTag;
|
|
use App\Services\Plugin\Parsers\ResponseParserRegistry;
|
|
use App\Services\PluginImportService;
|
|
use Carbon\Carbon;
|
|
use Exception;
|
|
use Illuminate\Database\Eloquent\Factories\HasFactory;
|
|
use Illuminate\Database\Eloquent\Model;
|
|
use Illuminate\Http\Client\Response;
|
|
use Illuminate\Support\Facades\App;
|
|
use Illuminate\Support\Facades\Blade;
|
|
use Illuminate\Support\Facades\Http;
|
|
use Illuminate\Support\Facades\Log;
|
|
use Illuminate\Support\Facades\Process;
|
|
use Illuminate\Support\Str;
|
|
use Keepsuit\LaravelLiquid\LaravelLiquidExtension;
|
|
use Keepsuit\Liquid\Exceptions\LiquidException;
|
|
use Keepsuit\Liquid\Extensions\StandardExtension;
|
|
|
|
class Plugin extends Model
|
|
{
|
|
use HasFactory;
|
|
|
|
protected $guarded = ['id'];
|
|
|
|
protected $casts = [
|
|
'data_payload' => 'json',
|
|
'data_payload_updated_at' => 'datetime',
|
|
'is_native' => 'boolean',
|
|
'markup_language' => 'string',
|
|
'configuration' => 'json',
|
|
'configuration_template' => 'json',
|
|
'no_bleed' => 'boolean',
|
|
'dark_mode' => 'boolean',
|
|
'preferred_renderer' => 'string',
|
|
];
|
|
|
|
protected static function boot()
|
|
{
|
|
parent::boot();
|
|
|
|
static::creating(function ($model): void {
|
|
if (empty($model->uuid)) {
|
|
$model->uuid = Str::uuid();
|
|
}
|
|
});
|
|
}
|
|
|
|
public function user()
|
|
{
|
|
return $this->belongsTo(User::class);
|
|
}
|
|
|
|
public function hasMissingRequiredConfigurationFields(): bool
|
|
{
|
|
if (! isset($this->configuration_template['custom_fields']) || empty($this->configuration_template['custom_fields'])) {
|
|
return false;
|
|
}
|
|
|
|
foreach ($this->configuration_template['custom_fields'] as $field) {
|
|
// Skip fields as they are informational only
|
|
if ($field['field_type'] === 'author_bio') {
|
|
continue;
|
|
}
|
|
|
|
if ($field['field_type'] === 'copyable') {
|
|
continue;
|
|
}
|
|
|
|
if ($field['field_type'] === 'copyable_webhook_url') {
|
|
continue;
|
|
}
|
|
|
|
$fieldKey = $field['keyname'] ?? $field['key'] ?? $field['name'];
|
|
|
|
// Check if field is required (not marked as optional)
|
|
$isRequired = ! isset($field['optional']) || $field['optional'] !== true;
|
|
|
|
if ($isRequired) {
|
|
$currentValue = $this->configuration[$fieldKey] ?? null;
|
|
|
|
// If the field has a default value and no current value is set, it's not missing
|
|
if ((in_array($currentValue, [null, '', []], true)) && ! isset($field['default'])) {
|
|
return true; // Found a required field that is not set and has no default
|
|
}
|
|
}
|
|
}
|
|
|
|
return false; // All required fields are set
|
|
}
|
|
|
|
public function isDataStale(): bool
|
|
{
|
|
if ($this->data_strategy === 'webhook') {
|
|
// Treat as stale if any webhook event has occurred in the past hour
|
|
return $this->data_payload_updated_at && $this->data_payload_updated_at->gt(now()->subHour());
|
|
}
|
|
if (! $this->data_payload_updated_at || ! $this->data_stale_minutes) {
|
|
return true;
|
|
}
|
|
|
|
return $this->data_payload_updated_at->addMinutes($this->data_stale_minutes)->isPast();
|
|
}
|
|
|
|
public function updateDataPayload(): void
|
|
{
|
|
if ($this->data_strategy === 'polling' && $this->polling_url) {
|
|
|
|
$headers = ['User-Agent' => 'usetrmnl/byos_laravel', 'Accept' => 'application/json'];
|
|
|
|
if ($this->polling_header) {
|
|
// Resolve Liquid variables in the polling header
|
|
$resolvedHeader = $this->resolveLiquidVariables($this->polling_header);
|
|
$headerLines = explode("\n", mb_trim($resolvedHeader));
|
|
foreach ($headerLines as $line) {
|
|
$parts = explode(':', $line, 2);
|
|
if (count($parts) === 2) {
|
|
$headers[mb_trim($parts[0])] = mb_trim($parts[1]);
|
|
}
|
|
}
|
|
}
|
|
|
|
// Resolve Liquid variables in the entire polling_url field first, then split by newline
|
|
$resolvedPollingUrls = $this->resolveLiquidVariables($this->polling_url);
|
|
$urls = array_filter(
|
|
array_map('trim', explode("\n", $resolvedPollingUrls)),
|
|
fn ($url): bool => ! empty($url)
|
|
);
|
|
|
|
// If only one URL, use the original logic without nesting
|
|
if (count($urls) === 1) {
|
|
$url = reset($urls);
|
|
$httpRequest = Http::withHeaders($headers);
|
|
|
|
if ($this->polling_verb === 'post' && $this->polling_body) {
|
|
// Resolve Liquid variables in the polling body
|
|
$resolvedBody = $this->resolveLiquidVariables($this->polling_body);
|
|
$httpRequest = $httpRequest->withBody($resolvedBody);
|
|
}
|
|
|
|
// URL is already resolved, use it directly
|
|
$resolvedUrl = $url;
|
|
|
|
try {
|
|
// Make the request based on the verb
|
|
$httpResponse = $this->polling_verb === 'post' ? $httpRequest->post($resolvedUrl) : $httpRequest->get($resolvedUrl);
|
|
|
|
$response = $this->parseResponse($httpResponse);
|
|
|
|
$this->update([
|
|
'data_payload' => $response,
|
|
'data_payload_updated_at' => now(),
|
|
]);
|
|
} catch (Exception $e) {
|
|
Log::warning("Failed to fetch data from URL {$resolvedUrl}: ".$e->getMessage());
|
|
$this->update([
|
|
'data_payload' => ['error' => 'Failed to fetch data'],
|
|
'data_payload_updated_at' => now(),
|
|
]);
|
|
}
|
|
|
|
return;
|
|
}
|
|
|
|
// Multiple URLs - use nested response logic
|
|
$combinedResponse = [];
|
|
|
|
foreach ($urls as $index => $url) {
|
|
$httpRequest = Http::withHeaders($headers);
|
|
|
|
if ($this->polling_verb === 'post' && $this->polling_body) {
|
|
// Resolve Liquid variables in the polling body
|
|
$resolvedBody = $this->resolveLiquidVariables($this->polling_body);
|
|
$httpRequest = $httpRequest->withBody($resolvedBody);
|
|
}
|
|
|
|
// URL is already resolved, use it directly
|
|
$resolvedUrl = $url;
|
|
|
|
try {
|
|
// Make the request based on the verb
|
|
$httpResponse = $this->polling_verb === 'post' ? $httpRequest->post($resolvedUrl) : $httpRequest->get($resolvedUrl);
|
|
|
|
$response = $this->parseResponse($httpResponse);
|
|
|
|
// Check if response is an array at root level
|
|
if (array_keys($response) === range(0, count($response) - 1)) {
|
|
// Response is a sequential array, nest under .data
|
|
$combinedResponse["IDX_{$index}"] = ['data' => $response];
|
|
} else {
|
|
// Response is an object or associative array, keep as is
|
|
$combinedResponse["IDX_{$index}"] = $response;
|
|
}
|
|
} catch (Exception $e) {
|
|
// Log error and continue with other URLs
|
|
Log::warning("Failed to fetch data from URL {$resolvedUrl}: ".$e->getMessage());
|
|
$combinedResponse["IDX_{$index}"] = ['error' => 'Failed to fetch data'];
|
|
}
|
|
}
|
|
|
|
$this->update([
|
|
'data_payload' => $combinedResponse,
|
|
'data_payload_updated_at' => now(),
|
|
]);
|
|
}
|
|
}
|
|
|
|
private function parseResponse(Response $httpResponse): array
|
|
{
|
|
$parsers = app(ResponseParserRegistry::class)->getParsers();
|
|
|
|
foreach ($parsers as $parser) {
|
|
$parserName = class_basename($parser);
|
|
|
|
try {
|
|
$result = $parser->parse($httpResponse);
|
|
|
|
if ($result !== null) {
|
|
return $result;
|
|
}
|
|
} catch (Exception $e) {
|
|
Log::warning("Failed to parse {$parserName} response: ".$e->getMessage());
|
|
}
|
|
}
|
|
|
|
return ['error' => 'Failed to parse response'];
|
|
}
|
|
|
|
/**
|
|
* Apply Liquid template replacements (converts 'with' syntax to comma syntax)
|
|
*/
|
|
private function applyLiquidReplacements(string $template): string
|
|
{
|
|
|
|
$replacements = [];
|
|
|
|
// Apply basic replacements
|
|
$template = str_replace(array_keys($replacements), array_values($replacements), $template);
|
|
|
|
// Convert Ruby/strftime date formats to PHP date formats
|
|
$template = $this->convertDateFormats($template);
|
|
|
|
// Convert {% render "template" with %} syntax to {% render "template", %} syntax
|
|
$template = preg_replace(
|
|
'/{%\s*render\s+([^}]+?)\s+with\s+/i',
|
|
'{% render $1, ',
|
|
$template
|
|
);
|
|
|
|
// Convert for loops with filters to use temporary variables
|
|
// This handles: {% for item in collection | filter: "key", "value" %}
|
|
// Converts to: {% assign temp_filtered = collection | filter: "key", "value" %}{% for item in temp_filtered %}
|
|
$template = preg_replace_callback(
|
|
'/{%\s*for\s+(\w+)\s+in\s+([^|%}]+)\s*\|\s*([^%}]+)%}/',
|
|
function (array $matches): string {
|
|
$variableName = mb_trim($matches[1]);
|
|
$collection = mb_trim($matches[2]);
|
|
$filter = mb_trim($matches[3]);
|
|
$tempVarName = '_temp_'.uniqid();
|
|
|
|
return "{% assign {$tempVarName} = {$collection} | {$filter} %}{% for {$variableName} in {$tempVarName} %}";
|
|
},
|
|
(string) $template
|
|
);
|
|
|
|
return $template;
|
|
}
|
|
|
|
/**
|
|
* Convert Ruby/strftime date formats to PHP date formats in Liquid templates
|
|
*/
|
|
private function convertDateFormats(string $template): string
|
|
{
|
|
// Handle date filter formats: date: "format" or date: 'format'
|
|
$template = preg_replace_callback(
|
|
'/date:\s*(["\'])([^"\']+)\1/',
|
|
function (array $matches): string {
|
|
$quote = $matches[1];
|
|
$format = $matches[2];
|
|
$convertedFormat = \App\Liquid\Utils\ExpressionUtils::strftimeToPhpFormat($format);
|
|
|
|
return 'date: '.$quote.$convertedFormat.$quote;
|
|
},
|
|
$template
|
|
);
|
|
|
|
// Handle l_date filter formats: l_date: "format" or l_date: 'format'
|
|
$template = preg_replace_callback(
|
|
'/l_date:\s*(["\'])([^"\']+)\1/',
|
|
function (array $matches): string {
|
|
$quote = $matches[1];
|
|
$format = $matches[2];
|
|
$convertedFormat = \App\Liquid\Utils\ExpressionUtils::strftimeToPhpFormat($format);
|
|
|
|
return 'l_date: '.$quote.$convertedFormat.$quote;
|
|
},
|
|
(string) $template
|
|
);
|
|
|
|
return $template;
|
|
}
|
|
|
|
/**
|
|
* Check if a template contains a Liquid for loop pattern
|
|
*
|
|
* @param string $template The template string to check
|
|
* @return bool True if the template contains a for loop pattern
|
|
*/
|
|
private function containsLiquidForLoop(string $template): bool
|
|
{
|
|
return preg_match('/{%-?\s*for\s+/i', $template) === 1;
|
|
}
|
|
|
|
/**
|
|
* Resolve Liquid variables in a template string using the Liquid template engine
|
|
*
|
|
* Uses the external trmnl-liquid renderer when:
|
|
* - preferred_renderer is 'trmnl-liquid'
|
|
* - External renderer is enabled in config
|
|
* - Template contains a Liquid for loop pattern
|
|
*
|
|
* Otherwise uses the internal PHP-based Liquid renderer.
|
|
*
|
|
* @param string $template The template string containing Liquid variables
|
|
* @return string The resolved template with variables replaced with their values
|
|
*
|
|
* @throws LiquidException
|
|
* @throws Exception
|
|
*/
|
|
public function resolveLiquidVariables(string $template): string
|
|
{
|
|
// Get configuration variables - make them available at root level
|
|
$variables = $this->configuration ?? [];
|
|
|
|
// Check if external renderer should be used
|
|
$useExternalRenderer = $this->preferred_renderer === 'trmnl-liquid'
|
|
&& config('services.trmnl.liquid_enabled')
|
|
&& $this->containsLiquidForLoop($template);
|
|
|
|
if ($useExternalRenderer) {
|
|
// Use external Ruby liquid renderer
|
|
return $this->renderWithExternalLiquidRenderer($template, $variables);
|
|
}
|
|
|
|
// Use the Liquid template engine to resolve variables
|
|
$environment = App::make('liquid.environment');
|
|
$environment->filterRegistry->register(StandardFilters::class);
|
|
$liquidTemplate = $environment->parseString($template);
|
|
$context = $environment->newRenderContext(data: $variables);
|
|
|
|
return $liquidTemplate->render($context);
|
|
}
|
|
|
|
/**
|
|
* Render template using external Ruby liquid renderer
|
|
*
|
|
* @param string $template The liquid template string
|
|
* @param array $context The render context data
|
|
* @return string The rendered HTML
|
|
*
|
|
* @throws Exception
|
|
*/
|
|
private function renderWithExternalLiquidRenderer(string $template, array $context): string
|
|
{
|
|
$liquidPath = config('services.trmnl.liquid_path');
|
|
|
|
if (empty($liquidPath)) {
|
|
throw new Exception('External liquid renderer path is not configured');
|
|
}
|
|
|
|
// HTML encode the template
|
|
$encodedTemplate = htmlspecialchars($template, ENT_QUOTES, 'UTF-8');
|
|
|
|
// Encode context as JSON
|
|
$jsonContext = json_encode($context, JSON_UNESCAPED_UNICODE | JSON_UNESCAPED_SLASHES);
|
|
|
|
if ($jsonContext === false) {
|
|
throw new Exception('Failed to encode render context as JSON: '.json_last_error_msg());
|
|
}
|
|
|
|
// Validate argument sizes
|
|
app(PluginImportService::class)->validateExternalRendererArguments($encodedTemplate, $jsonContext, $liquidPath);
|
|
|
|
// Execute the external renderer
|
|
$process = Process::run([
|
|
$liquidPath,
|
|
'--template',
|
|
$encodedTemplate,
|
|
'--context',
|
|
$jsonContext,
|
|
]);
|
|
|
|
if (! $process->successful()) {
|
|
$errorOutput = $process->errorOutput() ?: $process->output();
|
|
throw new Exception('External liquid renderer failed: '.$errorOutput);
|
|
}
|
|
|
|
return $process->output();
|
|
}
|
|
|
|
/**
|
|
* Render the plugin's markup
|
|
*
|
|
* @throws LiquidException
|
|
*/
|
|
public function render(string $size = 'full', bool $standalone = true, ?Device $device = null): string
|
|
{
|
|
if ($this->render_markup) {
|
|
$renderedContent = '';
|
|
|
|
if ($this->markup_language === 'liquid') {
|
|
// Get timezone from user or fall back to app timezone
|
|
$timezone = $this->user->timezone ?? config('app.timezone');
|
|
|
|
// Calculate UTC offset in seconds
|
|
$utcOffset = (string) Carbon::now($timezone)->getOffset();
|
|
|
|
// Build render context
|
|
$context = [
|
|
'size' => $size,
|
|
'data' => $this->data_payload,
|
|
'config' => $this->configuration ?? [],
|
|
...(is_array($this->data_payload) ? $this->data_payload : []),
|
|
'trmnl' => [
|
|
'system' => [
|
|
'timestamp_utc' => now()->utc()->timestamp,
|
|
],
|
|
'user' => [
|
|
'utc_offset' => $utcOffset,
|
|
'name' => $this->user->name ?? 'Unknown User',
|
|
'locale' => 'en',
|
|
'time_zone_iana' => $timezone,
|
|
],
|
|
'plugin_settings' => [
|
|
'instance_name' => $this->name,
|
|
'strategy' => $this->data_strategy,
|
|
'dark_mode' => $this->dark_mode ? 'yes' : 'no',
|
|
'no_screen_padding' => $this->no_bleed ? 'yes' : 'no',
|
|
'polling_headers' => $this->polling_header,
|
|
'polling_url' => $this->polling_url,
|
|
'custom_fields_values' => [
|
|
...(is_array($this->configuration) ? $this->configuration : []),
|
|
],
|
|
],
|
|
],
|
|
];
|
|
|
|
// Check if external renderer should be used
|
|
if ($this->preferred_renderer === 'trmnl-liquid' && config('services.trmnl.liquid_enabled')) {
|
|
// Use external Ruby renderer - pass raw template without preprocessing
|
|
$renderedContent = $this->renderWithExternalLiquidRenderer($this->render_markup, $context);
|
|
} else {
|
|
// Use PHP keepsuit/liquid renderer
|
|
// Create a custom environment with inline templates support
|
|
$inlineFileSystem = new InlineTemplatesFileSystem();
|
|
$environment = new \Keepsuit\Liquid\Environment(
|
|
fileSystem: $inlineFileSystem,
|
|
extensions: [new StandardExtension(), new LaravelLiquidExtension()]
|
|
);
|
|
|
|
// Register all custom filters
|
|
$environment->filterRegistry->register(Data::class);
|
|
$environment->filterRegistry->register(Date::class);
|
|
$environment->filterRegistry->register(Localization::class);
|
|
$environment->filterRegistry->register(Numbers::class);
|
|
$environment->filterRegistry->register(StringMarkup::class);
|
|
$environment->filterRegistry->register(Uniqueness::class);
|
|
|
|
// Register the template tag for inline templates
|
|
$environment->tagRegistry->register(TemplateTag::class);
|
|
|
|
// Apply Liquid replacements (including 'with' syntax conversion)
|
|
$processedMarkup = $this->applyLiquidReplacements($this->render_markup);
|
|
|
|
$template = $environment->parseString($processedMarkup);
|
|
$liquidContext = $environment->newRenderContext(data: $context);
|
|
$renderedContent = $template->render($liquidContext);
|
|
}
|
|
} else {
|
|
$renderedContent = Blade::render($this->render_markup, [
|
|
'size' => $size,
|
|
'data' => $this->data_payload,
|
|
'config' => $this->configuration ?? [],
|
|
]);
|
|
}
|
|
|
|
if ($standalone) {
|
|
if ($size === 'full') {
|
|
return view('trmnl-layouts.single', [
|
|
'colorDepth' => $device?->colorDepth(),
|
|
'deviceVariant' => $device?->deviceVariant() ?? 'og',
|
|
'noBleed' => $this->no_bleed,
|
|
'darkMode' => $this->dark_mode,
|
|
'scaleLevel' => $device?->scaleLevel(),
|
|
'slot' => $renderedContent,
|
|
])->render();
|
|
}
|
|
|
|
return view('trmnl-layouts.mashup', [
|
|
'mashupLayout' => $this->getPreviewMashupLayoutForSize($size),
|
|
'colorDepth' => $device?->colorDepth(),
|
|
'deviceVariant' => $device?->deviceVariant() ?? 'og',
|
|
'darkMode' => $this->dark_mode,
|
|
'scaleLevel' => $device?->scaleLevel(),
|
|
'slot' => $renderedContent,
|
|
])->render();
|
|
|
|
}
|
|
|
|
return $renderedContent;
|
|
}
|
|
|
|
if ($this->render_markup_view) {
|
|
if ($standalone) {
|
|
return view('trmnl-layouts.single', [
|
|
'colorDepth' => $device?->colorDepth(),
|
|
'deviceVariant' => $device?->deviceVariant() ?? 'og',
|
|
'noBleed' => $this->no_bleed,
|
|
'darkMode' => $this->dark_mode,
|
|
'scaleLevel' => $device?->scaleLevel(),
|
|
'slot' => view($this->render_markup_view, [
|
|
'size' => $size,
|
|
'data' => $this->data_payload,
|
|
'config' => $this->configuration ?? [],
|
|
])->render(),
|
|
])->render();
|
|
}
|
|
|
|
return view($this->render_markup_view, [
|
|
'size' => $size,
|
|
'data' => $this->data_payload,
|
|
'config' => $this->configuration ?? [],
|
|
])->render();
|
|
|
|
}
|
|
|
|
return '<p>No render markup yet defined for this plugin.</p>';
|
|
}
|
|
|
|
/**
|
|
* Get a configuration value by key
|
|
*/
|
|
public function getConfiguration(string $key, $default = null)
|
|
{
|
|
return $this->configuration[$key] ?? $default;
|
|
}
|
|
|
|
public function getPreviewMashupLayoutForSize(string $size): string
|
|
{
|
|
return match ($size) {
|
|
'half_vertical' => '1Lx1R',
|
|
'quadrant' => '2x2',
|
|
default => '1Tx1B',
|
|
};
|
|
}
|
|
}
|