adminizer 4.6.0 → 4.7.0-build.221

package/controllers/list.js

@@ -1,122 +1,435 @@
 import { ControllerHelper } from "../helpers/controllerHelper.js";
 import { DataAccessor } from "../lib/DataAccessor.js";
-import { NodeTable } from "../lib/datatable/NodeTable.js";
+import { ListQueryBuilder } from "../lib/list-query-builder/ListQueryBuilder.js";
 import { Adminizer } from "../lib/Adminizer.js";
 import { inertiaListHelper } from "../helpers/inertiaListHelper.js";
-import { redirectToLogin } from '../helpers/inertiaAutHelper.js';
+import { FilterService } from "../lib/filters/FilterService.js";
+import { convertDatetimeConditions } from "../helpers/filterDatetimeHelper.js";
+import { getUiTranslations } from "../lib/ui-i18n/getUiTranslations.js";
+import { FILTER_UI_TRANSLATION_KEYS } from "../lib/ui-i18n/uiTranslationKeys.js";
 export default async function list(req, res) {
-    let entity = ControllerHelper.findEntityObject(req);
-    if (!entity.model) {
+    let modelResource = ControllerHelper.findModelResource(req);
+    if (!modelResource.model) {
         return res.status(404).send({ error: 'Not Found' });
     }
-    if (req.adminizer.config.auth.enable) {
-        if (!req.user) {
-            return redirectToLogin(req, res);
-        }
-        else if (!req.adminizer.accessRightsHelper.hasPermission(`read-${entity.name}-model`, req.user)) {
-            return res.sendStatus(403);
-        }
-    }
-    let dataAccessor = new DataAccessor(req.adminizer, req.user, entity, "list");
+    let dataAccessor = new DataAccessor(req.adminizer, req.user, modelResource, "list");
     let fields = dataAccessor.getFieldsConfig();
-    const header = inertiaListHelper(entity, req, fields);
-    let start = "0";
-    if (req.query.page) {
-        if (req.query.page === '1') {
-            start = "0";
+    const header = inertiaListHelper(modelResource, req, fields);
+    const i18nPage = getUiTranslations(req, FILTER_UI_TRANSLATION_KEYS);
+    // Parse pagination
+    const defaultPageSize = req.adminizer.config.list?.defaultPageSize ?? 50;
+    const page = req.query.page ? parseInt(req.query.page.toString(), 10) : 1;
+    const limit = req.query.count ? parseInt(req.query.count.toString(), 10) : defaultPageSize;
+    // Parse sorting
+    const orderColumn = req.query.column ? req.query.column.toString() : undefined;
+    const direction = req.query.direction === "asc" ? 'ASC' : 'DESC';
+    // Parse global search
+    const globalSearch = req.query.globalSearch ? req.query.globalSearch.toString() : "";
+    // Check for saved filter (filterId parameter)
+    const filterId = req.query.filterId ? req.query.filterId.toString() : undefined;
+    let savedFilter = null;
+    let savedColumns = [];
+    let filterError = null;
+    if (filterId) {
+        try {
+            // Handle temporary filter from session (keyed by model name)
+            if (filterId === 'temporary' && req.session?.temporaryFilters?.[modelResource.name]) {
+                const tempFilter = req.session.temporaryFilters[modelResource.name];
+                savedFilter = {
+                    id: 'temporary',
+                    name: tempFilter.name,
+                    conditions: tempFilter.conditions,
+                    modelName: modelResource.name,
+                    visibility: 'private',
+                    ownerId: req.user?.id || null,
+                    apiEnabled: false,
+                    version: 1,
+                    createdAt: new Date(),
+                    updatedAt: new Date()
+                };
+                // Use temporary filter columns if available
+                if (tempFilter.columns && Array.isArray(tempFilter.columns)) {
+                    savedColumns = tempFilter.columns.map((col, index) => ({
+                        id: index + 1,
+                        filter: 'temporary',
+                        fieldName: col.fieldName,
+                        order: col.order !== undefined ? col.order : index
+                    }));
+                }
+                else {
+                    savedColumns = [];
+                }
+            }
+            else if (filterId !== 'temporary') {
+                // Load saved filter from database
+                const filterService = new FilterService(req.adminizer);
+                const result = await filterService.getFilterWithColumns(filterId, req.user);
+                savedFilter = result.filter;
+                savedColumns = result.columns;
+                if (!savedFilter) {
+                    filterError = 'Filter not found or access denied';
+                }
+            }
+            else {
+                filterError = 'Temporary filter not found in session';
+            }
         }
-        else {
-            start = ((+req.query.page - 1) * +req.query.count).toString();
+        catch (err) {
+            Adminizer.log.error('Error loading filter:', err);
+            filterError = 'Error loading filter';
         }
     }
-    const count = req.query.count ? req.query.count.toString() : "5";
-    const orderColumn = req.query.column ? req.query.column.toString() : undefined; // if no column is set, default to first column
-    const direction = req.query.direction === "asc" ? 'asc' : "desc";
-    const globalSearch = req.query.globalSearch ? req.query.globalSearch.toString() : "";
+    // Update header with active filter name
+    if (savedFilter && savedFilter.name) {
+        header.activeFilterName = savedFilter.name;
+    }
+    // Parse column-specific search
     const searchColumns = req.query.searchColumn
         ? Array.isArray(req.query.searchColumn)
-            ? req.query.searchColumn.map(String)
-            : [req.query.searchColumn.toString()]
+            ? req.query.searchColumn.map(String).filter(c => c && c.trim() !== '')
+            : [String(req.query.searchColumn)].filter(c => c && c.trim() !== '')
         : [];
     const searchColumnValues = req.query.searchColumnValue
         ? Array.isArray(req.query.searchColumnValue)
-            ? req.query.searchColumnValue.map(String)
-            : [req.query.searchColumnValue.toString()]
+            ? req.query.searchColumnValue.map(v => v ? String(v) : "")
+            : [String(req.query.searchColumnValue)]
         : [];
-    // Collect {column, value} pairs, removing duplicate columns (leaving the latter)
+    // Collect {column, value} pairs, removing duplicate columns
     const searchMap = new Map();
     for (let i = 0; i < searchColumns.length; i++) {
         const column = searchColumns[i];
         const value = searchColumnValues[i] || "";
-        searchMap.set(column, value);
+        // Only add non-empty values
+        if (value && value.trim() !== '') {
+            searchMap.set(column, value);
+        }
     }
     const searchPairs = Array.from(searchMap.entries()).map(([column, value]) => ({
         column,
         value,
     }));
-    const { columns, nodeTreeColumns } = setColumns(fields, orderColumn, direction, searchPairs, req);
-    const RequestBody = {
-        draw: "1",
-        start: start,
-        length: count,
-        order: [
-            {
-                column: orderColumn,
-                dir: direction
-            }
-        ],
-        columns: [
-            {
-                data: "0", // actions column
-                searchable: "true",
-                orderable: "true",
-                search: { value: "", regex: false }
-            },
-            ...nodeTreeColumns
-        ],
-        search: { value: globalSearch, regex: false }
+    // Build filter conditions
+    let filters = [];
+    // If saved filter, use its conditions (with datetime conversion)
+    if (savedFilter && savedFilter.conditions) {
+        filters = convertDatetimeConditions(savedFilter.conditions, { dropEmptyValues: true });
+    }
+    // Apply custom columns if filter has them
+    let displayFields = getVisibleFields(fields);
+    let customColumnsConfig = null;
+    if (savedColumns.length > 0) {
+        customColumnsConfig = savedColumns;
+        // Filter and reorder fields based on custom column configuration
+        displayFields = applyCustomColumns(displayFields, savedColumns);
+    }
+    // Add column search conditions (with datetime conversion)
+    const searchFilters = buildFiltersFromSearchPairs(displayFields, searchPairs);
+    if (searchFilters && searchFilters.length > 0) {
+        filters = [...filters, ...convertDatetimeConditions(searchFilters, { dropEmptyValues: true })];
+    }
+    // Prepare columns for frontend
+    const columns = setColumns(displayFields, orderColumn, direction.toLowerCase(), searchPairs, req);
+    // Convert column index to field name based on display fields
+    const sortField = orderColumn ? getFieldNameByIndex(displayFields, parseInt(orderColumn, 10)) : undefined;
+    // Determine sort field - prefer URL param, then filter setting
+    let effectiveSortField = sortField;
+    let effectiveSortDirection = direction;
+    if (!effectiveSortField && savedFilter?.sortField) {
+        effectiveSortField = savedFilter.sortField;
+        effectiveSortDirection = savedFilter.sortDirection || 'DESC';
+    }
+    // Build query parameters
+    const queryParams = {
+        page,
+        limit,
+        sort: effectiveSortField,
+        sortDirection: effectiveSortDirection,
+        filters: filters && filters.length > 0 ? filters : undefined,
+        globalSearch: globalSearch || undefined
     };
-    const nodeTable = new NodeTable(RequestBody, entity.model, fields);
-    await nodeTable.output((err, data) => {
-        if (err) {
-            Adminizer.log.error(err);
+    // Execute query using ListQueryBuilder (use original fields for query, displayFields for output)
+    const listQueryBuilder = new ListQueryBuilder(modelResource.model, fields, dataAccessor, req.adminizer.customFilterHandler);
+    try {
+        const result = await listQueryBuilder.execute(queryParams);
+        // Build active filter info for frontend
+        const activeFilter = savedFilter ? {
+            id: savedFilter.id,
+            name: savedFilter.name,
+            description: savedFilter.description,
+            icon: savedFilter.icon,
+            color: savedFilter.color,
+            conditions: savedFilter.conditions
+        } : null;
+        // Build field name mapping for display
+        const fieldNames = {};
+        Object.entries(fields).forEach(([key, field]) => {
+            if (field && typeof field === 'object') {
+                fieldNames[key] = field.title || key;
+            }
+        });
+        // Format conditions with field names for display
+        const formattedConditions = savedFilter?.conditions?.map((cond) => {
+            if (cond.field) {
+                return {
+                    ...cond,
+                    fieldName: fieldNames[cond.field] || cond.field
+                };
+            }
+            if (cond.customHandler) {
+                const customHandlerName = cond.customHandlerName
+                    || req.adminizer.customFilterHandler?.get(cond.customHandler)?.name;
+                const fallbackField = typeof cond.customHandler === 'string'
+                    ? cond.customHandler.split('.').pop()
+                    : '';
+                const resolvedField = fallbackField && fieldNames[fallbackField]
+                    ? fieldNames[fallbackField]
+                    : (fallbackField || cond.customHandler);
+                return {
+                    ...cond,
+                    fieldName: resolvedField,
+                    customHandlerName
+                };
+            }
+            if (cond.relation && cond.relationField) {
+                const relationField = fields[cond.relation];
+                const relationLabel = relationField?.config?.title || cond.relation;
+                const nestedLabel = relationField?.populated?.[cond.relationField]?.config?.title || cond.relationField;
+                return {
+                    ...cond,
+                    fieldName: `${relationLabel}.${nestedLabel}`
+                };
+            }
+            return {
+                ...cond,
+                fieldName: ''
+            };
+        }) || [];
+        // Update header with active filter name
+        if (savedFilter && savedFilter.name) {
+            header.activeFilterName = savedFilter.name;
+            header.activeFilterConditions = formattedConditions;
         }
         return req.Inertia.render({
             component: 'list',
             props: {
                 header: header,
                 columns: columns,
-                data: data ?? [],
+                data: {
+                    data: result.data,
+                    recordsTotal: result.total,
+                    recordsFiltered: result.filtered,
+                    page: result.page,
+                    pages: result.pages
+                },
+                activeFilter: activeFilter,
+                filterError: filterError,
+                customColumns: customColumnsConfig,
+                i18nPage
+            }
+        });
+    }
+    catch (err) {
+        Adminizer.log.error(err);
+        return req.Inertia.render({
+            component: 'list',
+            props: {
+                header: header,
+                columns: columns,
+                data: {
+                    data: [],
+                    recordsTotal: 0,
+                    recordsFiltered: 0,
+                    page: 1,
+                    pages: 0
+                },
+                activeFilter: null,
+                filterError: filterError || 'Query execution error',
+                customColumns: null,
+                i18nPage
             }
         });
-    }, dataAccessor);
+    }
 }
+/**
+ * Apply custom column configuration to fields
+ * Returns fields filtered and ordered according to saved column config
+ */
+function applyCustomColumns(fields, columns) {
+    // Sort columns by order
+    const sortedColumns = [...columns].sort((a, b) => (a.order || 0) - (b.order || 0));
+    // Only include visible columns that exist in fields
+    const visibleColumns = sortedColumns.filter(col => fields[col.fieldName]);
+    // If no visible columns configured, return original fields
+    if (visibleColumns.length === 0) {
+        return fields;
+    }
+    // Build new fields object with custom order
+    const result = {};
+    for (const col of visibleColumns) {
+        const field = fields[col.fieldName];
+        if (field) {
+            result[col.fieldName] = field;
+        }
+    }
+    return result;
+}
+function getVisibleFields(fields) {
+    return Object.entries(fields).reduce((result, [key, field]) => {
+        const config = field?.config;
+        if (config?.visible === false) {
+            return result;
+        }
+        result[key] = field;
+        return result;
+    }, {});
+}
+/**
+ * Get field name by column index
+ */
+function getFieldNameByIndex(fields, index) {
+    const fieldNames = Object.keys(fields);
+    // Index 0 is usually actions column, so actual fields start from index 1
+    const fieldIndex = index - 1;
+    return fieldIndex >= 0 && fieldIndex < fieldNames.length ? fieldNames[fieldIndex] : undefined;
+}
+/**
+ * Build FilterCondition[] from search pairs
+ * Supports:
+ * - String: contains search
+ * - Number: exact match, > (greater than), < (less than)
+ * - Boolean: true/false, 1/0, yes/no
+ * - Date: exact match
+ */
+function buildFiltersFromSearchPairs(fields, searchPairs) {
+    const filters = [];
+    const fieldNames = Object.keys(fields);
+    for (const pair of searchPairs) {
+        // Skip empty values or LIKE patterns (starts and ends with %)
+        if (!pair.value || pair.value.trim() === '' ||
+            (pair.value.startsWith('%') && pair.value.endsWith('%'))) {
+            continue;
+        }
+        const fieldIndex = parseInt(pair.column, 10) - 1; // Column index starts from 1
+        if (fieldIndex < 0 || fieldIndex >= fieldNames.length) {
+            continue;
+        }
+        const fieldName = fieldNames[fieldIndex];
+        const field = fields[fieldName];
+        const fieldType = field.model?.type;
+        // Determine operator based on field type
+        let operator = 'like';
+        let value = pair.value;
+        if (fieldType === 'number' || fieldType === 'integer' || fieldType === 'float') {
+            // Support >, <, >=, <= operators for numbers
+            const searchStr = pair.value.trim();
+            if (searchStr.startsWith('>=')) {
+                const numValue = parseFloat(searchStr.substring(2));
+                if (!isNaN(numValue)) {
+                    operator = 'gte';
+                    value = numValue;
+                }
+                else {
+                    continue;
+                }
+            }
+            else if (searchStr.startsWith('>')) {
+                const numValue = parseFloat(searchStr.substring(1));
+                if (!isNaN(numValue)) {
+                    operator = 'gt';
+                    value = numValue;
+                }
+                else {
+                    continue;
+                }
+            }
+            else if (searchStr.startsWith('<=')) {
+                const numValue = parseFloat(searchStr.substring(2));
+                if (!isNaN(numValue)) {
+                    operator = 'lte';
+                    value = numValue;
+                }
+                else {
+                    continue;
+                }
+            }
+            else if (searchStr.startsWith('<')) {
+                const numValue = parseFloat(searchStr.substring(1));
+                if (!isNaN(numValue)) {
+                    operator = 'lt';
+                    value = numValue;
+                }
+                else {
+                    continue;
+                }
+            }
+            else {
+                // Exact match for numbers
+                const numValue = parseFloat(pair.value);
+                if (!isNaN(numValue)) {
+                    operator = 'eq';
+                    value = numValue;
+                }
+                else {
+                    continue; // Skip invalid number
+                }
+            }
+        }
+        else if (fieldType === 'boolean') {
+            const lowerValue = pair.value.toLowerCase();
+            if (lowerValue === 'true' || lowerValue === '1' || lowerValue === 'yes') {
+                value = true;
+            }
+            else if (lowerValue === 'false' || lowerValue === '0' || lowerValue === 'no') {
+                value = false;
+            }
+            else {
+                continue; // Skip invalid boolean
+            }
+            operator = 'eq';
+        }
+        else if (fieldType === 'date') {
+            // For date fields, parse and use exact match
+            const parsedDate = new Date(pair.value);
+            if (isNaN(parsedDate.getTime())) {
+                continue; // Skip invalid date
+            }
+            operator = 'eq';
+            value = parsedDate;
+        }
+        else if (fieldType === 'time') {
+            // Time fields can be searched with LIKE (stored as HH:MM)
+            operator = 'like';
+            value = pair.value;
+        }
+        filters.push({
+            id: `search-${fieldName}-${Date.now()}-${Math.random()}`,
+            field: fieldName,
+            operator,
+            value
+        });
+    }
+    return filters;
+}
+/**
+ * Set columns configuration for frontend
+ */
 function setColumns(fields, orderColumn, direction, searchPairs, req) {
     const columns = {};
-    const nodeTreeColumns = [];
     let i = 1;
     for (const key of Object.keys(fields)) {
         const field = fields[key];
-        // Check if this field is searchable
+        // Check if this field has search value
         const searchForThisColumn = searchPairs.find(pair => pair.column === String(i));
         const searchValue = searchForThisColumn ? searchForThisColumn.value : "";
         columns[key] = {
             ...field.config,
+            hasDisplayModifier: !!field.config.displayModifier,
             title: req.i18n.__(field.config.title),
             data: String(i),
             direction: String(i) === orderColumn ? direction : undefined,
-            searchColumnValue: searchValue || undefined, // undefined if there is no search
+            searchColumnValue: searchValue || undefined
         };
-        nodeTreeColumns.push({
-            data: String(i),
-            searchable: 'true',
-            orderable: 'true',
-            search: {
-                value: searchValue,
-                regex: false,
-            },
-        });
         i++;
     }
-    return { columns, nodeTreeColumns };
+    return columns;
 }

package/controllers/listUserFilters.d.ts

@@ -0,0 +1,5 @@
+/**
+ * GET /adminizer/model/userfilters
+ * Page controller for the user filters list view.
+ */
+export default function listUserFilters(req: ReqType, res: ResType): Promise<import("express").Response<any, Record<string, any>>>;

package/controllers/listUserFilters.js

@@ -0,0 +1,26 @@
+import { getUiTranslations } from "../lib/ui-i18n/getUiTranslations.js";
+import { USER_FILTERS_UI_TRANSLATION_KEYS } from "../lib/ui-i18n/uiTranslationKeys.js";
+/**
+ * GET /adminizer/model/userfilters
+ * Page controller for the user filters list view.
+ */
+export default async function listUserFilters(req, res) {
+    // Get all models for the dropdown
+    const allModels = req.adminizer.config.models || {};
+    const modelsList = Object.keys(allModels).map(name => {
+        const config = allModels[name];
+        return {
+            name,
+            title: config?.title || name
+        };
+    });
+    return req.Inertia.render({
+        component: 'user-filters-list',
+        props: {
+            title: req.i18n.__('User Filters'),
+            models: modelsList,
+            apiEndpoint: `${req.adminizer.config.routePrefix}/api/all-user-filters`,
+            i18nPage: getUiTranslations(req, USER_FILTERS_UI_TRANSLATION_KEYS)
+        }
+    });
+}

package/controllers/login.js

@@ -14,10 +14,10 @@ export default async function login(req, res) {
             let login = req.body.login;
             let password = req.body.password;
             let captchaSolution = req.body.captchaSolution;
+            const userModel = req.adminizer.modelHandler.internal("auth").get("UserAP");
             let user;
             try {
-                // TODO refactor CRUD functions for DataAccessor usage
-                user = await req.adminizer.modelHandler.model.get("UserAP")["_findOne"]({ login: login });
+                user = await userModel.findOne({ where: { login: login } });
             }
             catch (e) {
                 return res.status(500).send({ error: e.message || 'Internal Server Error' });

package/controllers/media-manager/mediaManagerApi.js

@@ -1,18 +1,9 @@
 import { MediaManagerAdapter } from "./mediaManagerAdapter.js";
-import { redirectToLogin } from '../../helpers/inertiaAutHelper.js';
 export async function mediaManagerController(req, res) {
     const method = req.method.toUpperCase();
     let id = req.params.id ? req.params.id : '';
     // const delay = (ms: number) => new Promise(resolve => setTimeout(resolve, ms));
     // await delay(1000);
-    if (req.adminizer.config.auth.enable) {
-        if (!req.user) {
-            return redirectToLogin(req, res);
-        }
-        else if (!req.adminizer.accessRightsHelper.hasPermission(`mediaManager-${id}`, req.user)) {
-            return res.sendStatus(403);
-        }
-    }
     if (!id) {
         return res.sendStatus(404);
     }

package/controllers/navigation/edit.js

@@ -1,14 +1,8 @@
 import { ControllerHelper } from "../../helpers/controllerHelper.js";
 import { DataAccessor } from "../../lib/DataAccessor.js";
-import { redirectToLogin } from '../../helpers/inertiaAutHelper.js';
 export default async function edit(req, res) {
-    if (req.adminizer.config.auth.enable) {
-        if (!req.user) {
-            return redirectToLogin(req, res);
-        }
-    }
-    let entity = ControllerHelper.findEntityObject(req);
-    let dataAccessor = new DataAccessor(req.adminizer, req.user, entity, "edit");
-    let record = await entity.model.findOne({ id: req.params.id }, dataAccessor);
+    let modelResource = ControllerHelper.findModelResource(req);
+    let dataAccessor = new DataAccessor(req.adminizer, req.user, modelResource, "edit");
+    let record = await modelResource.model.findOne({ where: { id: req.params.id } }, dataAccessor);
     return res.redirect(`${req.adminizer.config.routePrefix}/catalog/navigation/${record.label}`);
 }

package/controllers/notifications/NotificationController.d.ts

@@ -7,5 +7,5 @@ export declare class NotificationController {
     static getUserNotifications(req: ReqType, res: ResType): Promise<void>;
     static markAsRead(req: ReqType, res: ResType): Promise<void>;
     static markAllAsRead(req: ReqType, res: ResType): Promise<void>;
-    private static checkNotifPermission;
+    private static checkNotifStatus;
 }