@nauticana/sail 0.6.1 → 0.8.0

package/src/component/table/table_search.ts

@@ -1,9 +1,12 @@
-import { ChangeDetectionStrategy, ChangeDetectorRef, Component, inject, Input, OnInit, ViewEncapsulation } from "@angular/core";
+import { ChangeDetectionStrategy, ChangeDetectorRef, Component, effect, inject, input, OnInit, signal, ViewEncapsulation } from "@angular/core";
 import { MatButtonModule } from "@angular/material/button";
+import { MatIconModule } from "@angular/material/icon";
 import { ActivatedRoute, Router } from "@angular/router";
 import { BaseForm } from "../abstract/base_form";
 import { RecordForm } from "../form/form_record";
 import { ApplicationMenu } from "../../model/common";
+import { TableAction } from "../../model/appdata";
+import { BackendService } from "../../service/rest_service";
 
 @Component({
     selector: 'table-search',
@@ -12,36 +15,69 @@ import { ApplicationMenu } from "../../model/common";
     templateUrl: './table_search.html',
     imports: [
         MatButtonModule,
+        MatIconModule,
         RecordForm,
     ],
 })
 export class TableSearch extends BaseForm implements OnInit {
-    @Input() override tableName = '';
-    @Input() apiName: string = '';
-    @Input() targetRoute: string = '';
+    readonly tableNameInput = input('', { alias: 'tableName' });
+    readonly apiNameInput = input('', { alias: 'apiName' });
+    readonly targetRouteInput = input('', { alias: 'targetRoute' });
+    readonly apiName = signal('');
+    readonly targetRoute = signal('');
     searchColumns: string[] = [];
 
+    constructor() {
+        super();
+        effect(() => { const v = this.tableNameInput();  if (v) this.tableName.set(v); });
+        effect(() => { const v = this.apiNameInput();    if (v) this.apiName.set(v); });
+        effect(() => { const v = this.targetRouteInput();if (v) this.targetRoute.set(v); });
+    }
+
     private readonly router = inject(Router);
     private readonly route = inject(ActivatedRoute);
     private readonly cdr = inject(ChangeDetectorRef);
+    private readonly backendService = inject(BackendService);
+
+    /**
+     * Fire a table-level TableAction from the search-screen toolbar.
+     * Record-specific actions never show up here — search has no
+     * row context.
+     */
+    executeAction(action: TableAction): void {
+        if (!this.canExecuteAction(action)) {
+            alert(`Missing authorization for action ${action.authorityObject}/${action.authorityCheck}`);
+            return;
+        }
+        if (action.confirmMessage && !confirm(action.confirmMessage)) return;
+        this.backendService.executeAction(action.method, {}).subscribe({
+            next: () => {/* no-op — search screen has no list to refresh */},
+            error: (err) => {
+                console.error(`Action ${action.action} failed`, err);
+                alert(err?.error?.detail ?? `Failed to ${action.caption}`);
+            },
+        });
+    }
 
     ngOnInit() {
         const data = this.route.snapshot.data;
-        if (!this.tableName && data['tableName']) this.tableName = data['tableName'];
-        if (!this.apiName && data['apiName']) this.apiName = data['apiName'];
-        if (!this.targetRoute && data['targetRoute']) this.targetRoute = data['targetRoute'];
+        if (!this.tableName() && data['tableName']) this.tableName.set(data['tableName']);
+        if (!this.apiName() && data['apiName']) this.apiName.set(data['apiName']);
+        if (!this.targetRoute() && data['targetRoute']) this.targetRoute.set(data['targetRoute']);
         this.title = this.getCaption() + ' Search';
-        if (!this.targetRoute && (this.apiName || this.tableName)) {
+        if (!this.targetRoute() && (this.apiName() || this.tableName())) {
             this.cacheService.getMenus().subscribe((menus: ApplicationMenu[]) => {
+                const apiName = this.apiName();
+                const tableName = this.tableName();
                 for (const menu of menus) {
                     for (const page of menu.ApplicationMenuItems!) {
-                        if (this.apiName.endsWith(page.RestUri!) ||
-                            (this.tableName && page.RestUri!.includes(this.tableName))
+                        if (apiName.endsWith(page.RestUri!) ||
+                            (tableName && page.RestUri!.includes(tableName))
                         ) {
                             if (page.FilterOnList) {
-                                this.targetRoute = '/' + menu.Id!.toLowerCase() + '/' + page.ItemId!;
+                                this.targetRoute.set('/' + menu.Id!.toLowerCase() + '/' + page.ItemId!);
                             } else {
-                                this.targetRoute = '/' + menu.Id!.toLowerCase() + '/' + page.ItemId! + '/list';
+                                this.targetRoute.set('/' + menu.Id!.toLowerCase() + '/' + page.ItemId! + '/list');
                             }
                             this.cdr.markForCheck();
                             return;
@@ -55,11 +91,12 @@ export class TableSearch extends BaseForm implements OnInit {
     }
 
     onSearch() {
-        if (!this.targetRoute) {
+        const targetRoute = this.targetRoute();
+        if (!targetRoute) {
             alert('Navigation target not found for this table');
             return;
         }
-        this.router.navigate([this.targetRoute], {queryParams: this.buildSearchTerms(this.editableRecord)});
+        this.router.navigate([targetRoute], {queryParams: this.buildSearchTerms(this.editableRecord)});
     }
 
     onClear() {
@@ -81,7 +118,7 @@ export class TableSearch extends BaseForm implements OnInit {
      */
     private emptySearchRecord(): any {
         const rec = this.emptyRecord();
-        const tableDef = this.cacheService.getTableDefinition(this.tableName);
+        const tableDef = this.cacheService.getTableDefinition(this.tableName());
         if (tableDef?.Columns) {
             for (const col of tableDef.Columns) {
                 if (col.DataType === 'boolean') {
@@ -97,10 +134,11 @@ export class TableSearch extends BaseForm implements OnInit {
             alert('Missing authorization to create records');
             return;
         }
-        if (!this.targetRoute) {
+        const targetRoute = this.targetRoute();
+        if (!targetRoute) {
             alert('Navigation target not found for this table');
             return;
         }
-        this.router.navigate([this.targetRoute], {queryParams: {'_action': 'create'}});
+        this.router.navigate([targetRoute], {queryParams: {'_action': 'create'}});
     }
 }

package/src/model/appdata.ts

@@ -56,13 +56,27 @@ export interface TableColumn {
   Validators?:  AbstractControlOptions['validators'];
 }
 
+// One custom button registered against a table via the basis
+// table_action seed. Auth gating uses the existing
+// authorization_role_permission path against (authorityObject,
+// authorityCheck, low_limit=tableName) — see canExecute() in
+// BaseAuthService.
+//
+// recordSpecific=true  → button renders next to per-row edit/delete.
+// recordSpecific=false → button renders next to the "New Record" toolbar.
+//
+// `method` is the URL POST target the click should hit (resolved by
+// keel from table_name + action_name + optional method_name override).
 export interface TableAction {
-  action:         string;
-  caption:        string;
-  method:         string;
-  enable:         string;
-  authorityCheck: string;
-  recordSpecific: string;
+  action:           string;   // lowercase action_name
+  caption:          string;
+  method:           string;   // resolved URL path (POST target)
+  icon?:            string;   // Material icon name; falsy → label-only
+  recordSpecific:   boolean;
+  displayOrder?:    number;
+  confirmMessage?:  string;
+  authorityObject:  string;   // uppercased table_name — for canExecute()
+  authorityCheck:   string;   // uppercased action_name — for canExecute()
 }
 
 export interface ForeignKey {

package/src/service/auth.service.ts

@@ -471,6 +471,15 @@ export abstract class BaseAuthService {
   canCreate(tableName: string) { return this.checkPermission('TABLE', 'INSERT', tableName); }
   canUpdate(tableName: string) { return this.checkPermission('TABLE', 'UPDATE', tableName); }
   canDelete(tableName: string) { return this.checkPermission('TABLE', 'DELETE', tableName); }
+  /**
+   * Authorization check for a custom TableAction. authorityObject is the
+   * uppercased table_name; activity is the uppercased action_name. The
+   * grant's low_limit is checked against the table_name (lowercase) —
+   * matching the convention populated by keel's loadTableActions.
+   */
+  canExecute(authorityObject: string, activity: string, tableName: string): boolean {
+    return this.checkPermission(authorityObject, activity, tableName);
+  }
   canAccess(pageName: string)  { return this.checkPermission('PAGE', 'ACCESS', pageName); }
   canReport(reportName: string) { return this.checkPermission('REPORT', 'ACCESS', reportName); }
 

package/src/service/rest_service.ts

@@ -91,4 +91,16 @@ export class BackendService {
     delete(apiName: string, filter?: {[key: string]: string}): Observable<{message: string}> {
         return this.http.delete<{message: string}>(this.apiUrl(apiName + '/delete'), {params: this.toParams(filter)}).pipe(catchError(this.handleError));
     }
+
+    /**
+     * Fire a TableAction button. `actionPath` is the resolved URL path
+     * the keel REST engine pre-computed onto TableAction.method
+     * (e.g. "/user_payment_method/set_default"); pass it verbatim and
+     * the call will POST to {host}{api_prefix}{actionPath} with the
+     * supplied body. For record-specific actions the body carries the
+     * primary key values; for table-level actions it is typically `{}`.
+     */
+    executeAction<T = unknown>(actionPath: string, body: Record<string, unknown> = {}): Observable<T> {
+        return this.http.post<T>(this.apiUrl(actionPath), body).pipe(catchError(this.handleError));
+    }
 }

package/src/service/rest_url.ts

@@ -37,9 +37,10 @@ export const RestURL = {
   payoutReusableLinkURL: '/api/v1/payout/reusable/link',
   payoutStatusURL:       '/api/v1/payout/status',
   // User payment methods — list/delete go through keel's generic REST
-  // CRUD against the UserSpecific basis table; only set-default has a
-  // custom endpoint (atomic multi-row UPDATE).
-  paymentMethodSetDefaultURL: '/api/v1/payment-methods/set-default',
+  // CRUD against the UserSpecific basis table; set-default is a
+  // TableAction (basis table_action row), mounted at the conventional
+  // URL POST /api/v1/user_payment_method/set_default.
+  paymentMethodSetDefaultURL: '/api/v1/user_payment_method/set_default',
 };
 
 /** Call this at app startup to set the backend host URL */