#PDF Templates

1
2
3
4
5
6
7
8
9
10

// config/signature.php
'templates' => [
    'dtr' => [
        'label'         => 'Daily Time Record',
        'view'          => 'pdf.dtr',  // your existing Blade
        'sample_data'   => ['user' => ['name' => 'Sample User']],
        'data_resolver' => fn ($record) => ['record' => $record],
        'slots'         => ['employee', 'in_charge'],
    ],
],

1
2
3
4
5
6
7
8
9
10
11
12
13
14

// 1) Bare keys — label auto-derived (Title Case of the key)
'slots' => ['employee', 'in_charge'],

// 2) Keyed associative entries — full control over each slot
'slots' => [
    'employee'  => ['label' => 'Employee', 'required' => true],
    'in_charge' => ['label' => 'In Charge', 'required' => true],
],

// 3) Numbered list of associative entries — useful when you want a stable order
'slots' => [
    ['key' => 'employee',  'label' => 'Employee',  'required' => true],
    ['key' => 'in_charge', 'label' => 'In Charge', 'required' => true],
],

1
2

app(\Kukux\DigitalSignature\Services\PdfTemplateRegistry::class)->all();
// → ['dtr' => Kukux\DigitalSignature\Pdf\BladePdfTemplate { … }]

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25

// app/Pdf/BrowsershotRenderer.php
use Kukux\DigitalSignature\Pdf\Renderers\PdfRenderer;

class BrowsershotRenderer implements PdfRenderer
{
    public function render(string $view, array $data, string $destinationPath): string
    {
        \Spatie\LaravelPdf\Facades\Pdf::view($view, $data)->save($destinationPath);
        return $destinationPath;
    }

    public static function isAvailable(): bool
    {
        return class_exists(\Spatie\LaravelPdf\Facades\Pdf::class);
    }
}

// config/signature.php
'templates' => [
    'dtr' => [
        'view'     => 'pdf.dtr',
        'renderer' => \App\Pdf\BrowsershotRenderer::class,
        // …
    ],
],

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86

namespace App\Pdf;

use App\Models\Dtr;
use Illuminate\Database\Eloquent\Model;
use Illuminate\Support\Facades\Storage;
use Kukux\DigitalSignature\Contracts\PdfTemplate;
use Kukux\DigitalSignature\Pdf\SlotDefinition;

class DtrTemplate implements PdfTemplate
{
    public function key(): string
    {
        return 'dtr';
    }

    public function label(): string
    {
        return 'Daily Time Record';
    }

    /**
     * Named regions on the DTR PDF that can accept a signature.
     * Defaults are starting suggestions only — admins override via
     * the placement designer (or by writing to digital_pdf_template_slots).
     */
    public function slots(): array
    {
        return [
            new SlotDefinition(
                key:           'employee',
                label:         'Employee',
                defaultPage:   1,
                defaultX:      135,
                defaultY:      90,
                defaultWidth:  200,
                defaultHeight: 40,
                required:      true,
            ),
            new SlotDefinition(
                key:           'in_charge',
                label:         'In Charge',
                defaultPage:   1,
                defaultX:      520,
                defaultY:      90,
                defaultWidth:  200,
                defaultHeight: 40,
                required:      true,
            ),
        ];
    }

    /**
     * Sample PDF used to preview the layout in the designer.
     * Should be deterministic so the rasterized preview can be cached.
     */
    public function renderSample(): string
    {
        $disk = Storage::disk(config('signature.storage_disk'));
        $rel  = 'samples/dtr.pdf';

        if (! $disk->exists($rel)) {
            $disk->put($rel, app(DtrPdfRenderer::class)->renderBinarySample());
        }

        return $disk->path($rel);
    }

    /**
     * Render the production PDF for a specific record at sign time.
     * Same contract as Signable::getSignablePdfPath() — return an
     * absolute filesystem path the signer driver can read.
     */
    public function renderFor(Model $record): string
    {
        assert($record instanceof Dtr);

        $disk = Storage::disk(config('signature.storage_disk'));
        $rel  = "generated/dtr/{$record->getKey()}.pdf";

        if (! $disk->exists($rel)) {
            $disk->put($rel, app(DtrPdfRenderer::class)->renderBinary($record));
        }

        return $disk->path($rel);
    }
}

1
2
3
4
5
6
7
8
9
10
11
12

// config/signature.php

'templates' => [
    // Plug-and-play (array form)
    'dtr' => [
        'view'  => 'pdf.dtr',
        'slots' => ['employee', 'in_charge'],
    ],

    // Full class (class-string form)
    \App\Pdf\PayslipTemplate::class,
],

1
2
3
4
5
6
7
8
9
10
11
12

// app/Providers/Filament/AdminPanelProvider.php

->plugins([
    \Kukux\DigitalSignature\SignaturePlugin::make()
        ->templates([
            'dtr' => [
                'view'  => 'pdf.dtr',
                'slots' => ['employee', 'in_charge'],
            ],
            \App\Pdf\PayslipTemplate::class,
        ]),
])

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15

use Kukux\DigitalSignature\Services\PdfTemplateRegistry;

public function boot(): void
{
    $registry = app(PdfTemplateRegistry::class);

    // Array form via dedicated helper
    $registry->registerBlade('dtr', [
        'view'  => 'pdf.dtr',
        'slots' => ['employee', 'in_charge'],
    ]);

    // Class or instance
    $registry->register(\App\Pdf\PayslipTemplate::class);
}

1
2
3
4
5
6
7
8

use Kukux\DigitalSignature\Services\PdfTemplateRegistry;

$registry = app(PdfTemplateRegistry::class);

$registry->has('dtr');                 // bool
$registry->find('dtr');                // ?PdfTemplate (null if missing)
$registry->get('dtr');                 // PdfTemplate (throws if missing)
$registry->all();                      // array<string, PdfTemplate>

1

/<panel-path>/signature-templates/{templateKey}/design

1

/admin/signature-templates/dtr/design

1
2
3
4
5
6
7
8
9

use Filament\Actions\Action;

Action::make('design_layout')
    ->label('Design layout')
    ->icon('heroicon-o-rectangle-group')
    ->url(fn () => route('filament.admin.pages.signature-templates.{template-key}.design', [
        'templateKey' => 'dtr',
    ]))
    ->openUrlInNewTab(false);

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15

Browser                                                     Backend
┌────────────────────────────────────┐                     ┌──────────────────────────┐
│ PdfDesignerIsland (React)          │   GET /meta         │ DesignerController::meta │
│  ├─ fetches meta + saved slots ────┼────────────────────►│  - reads PdfTemplate     │
│  ├─ renders <img src=page/1>       │   GET /pages/1      │  - reads PdfTemplateSlot │
│  ├─ overlays SlotBox per slot      │◄────────────────────┤  - returns PDF point     │
│  ├─ user drags / resizes / nudges  │   PNG               │    dimensions per page   │
│  └─ Save → POST /slots/{slot} ─────┼────────────────────►│ DesignerController::page │
└────────────────────────────────────┘                     │  - rasterizes via Imagick│
                                                           │    (or RendersSample…)   │
                                                           ├──────────────────────────┤
                                                           │ DesignerController::save │
                                                           │  - upsert by             │
                                                           │    (template_key, slot)  │
                                                           └──────────────────────────┘

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19

use Kukux\DigitalSignature\Contracts\PdfTemplate;
use Kukux\DigitalSignature\Contracts\RendersSamplePageImage;

class DtrTemplate implements PdfTemplate, RendersSamplePageImage
{
    // ... existing PdfTemplate methods ...

    public function renderSampleAsImage(int $page): string
    {
        // Return an absolute path to a PNG/JPEG of $page.
        // For DomPDF / Spatie Browsershot / Snappy users: render directly to PNG.
        return app(DtrPdfRenderer::class)->renderPageAsPng(page: $page);
    }

    public function sampleImagePageCount(): int
    {
        return 1;
    }
}

1
2
3
4

// config/signature.php
'designer' => [
    'dpi' => env('SIGNATURE_DESIGNER_DPI', 144),
],

1
2
3
4
5
6

use Kukux\DigitalSignature\Models\PdfTemplateSlot;

PdfTemplateSlot::updateOrCreate(
    ['template_key' => 'dtr', 'slot_key' => 'employee'],
    ['page' => 1, 'x' => 135, 'y' => 90, 'width' => 200, 'height' => 40],
);

1

/<panel-path>/signature-templates/{templateKey}/sign/{signatureUuid}

1
2
3
4
5
6
7
8
9
10
11

PdfSigningIsland (React)
├─ Top bar:   Template label    [Cancel]  [Finish & Save]
├─ Canvas:    Rasterized PDF page with SlotBox overlays
│             ├─ Active signature image is rendered inside each placed slot
│             └─ Page selector when the template has > 1 page
├─ Slot picker (chips below the canvas):
│             ├─ "+ Employee", "+ In Charge", … one chip per declared slot
│             └─ Click adds the slot at the canvas center; click again removes
└─ Bottom strip: Your stored signatures
              ├─ Active signature highlighted with primary ring
              └─ Up to 12 other primary signatures (chip = click to swap)

1
2
3
4
5
6
7
8
9
10

use Illuminate\Database\Eloquent\Model;
use Kukux\DigitalSignature\Concerns\HasPdfTemplate;
use Kukux\DigitalSignature\Contracts\Signable;

class Dtr extends Model implements Signable
{
    use HasPdfTemplate;

    protected string $signaturePdfTemplate = 'dtr';   // matches the config key
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20

use Filament\Actions\Action;
use Kukux\DigitalSignature\Filament\Pages\PdfTemplateSigner;
use Kukux\DigitalSignature\Models\Signature;

Action::make('sign_with_my_signature')
    ->label('Sign')
    ->icon('heroicon-o-pencil-square')
    ->url(function ($record) {
        $signature = Signature::query()
            ->where('user_id', auth()->id())
            ->whereNull('signable_id')
            ->where('status', 'active')
            ->latest('id')
            ->firstOrFail();

        return PdfTemplateSigner::getUrl([
            'templateKey'   => 'dtr',
            'signatureUuid' => $signature->uuid,
        ]).'?signable='.$record->getKey();
    });