adminizer 4.6.0 → 4.7.0-build.221

package/controllers/feed.js

@@ -0,0 +1,73 @@
+import { FeedService } from "../services/FeedService.js";
+import { Adminizer } from "../lib/Adminizer.js";
+/**
+ * Public feed controller — exports data by apiKey with userKey authentication
+ * GET /adminizer/api/feed/:apiKey.json?userKey=xxx
+ * GET /adminizer/api/feed/:apiKey.xml?userKey=xxx
+ */
+export default async function feedController(req, res) {
+    const { apiKey, format } = req.params;
+    const userKey = req.query.userKey;
+    // Validate format
+    const exportFormat = (format || 'json').toLowerCase();
+    if (!['json', 'xml'].includes(exportFormat)) {
+        return res.status(400).json({ error: 'Invalid format. Supported: json, xml' });
+    }
+    if (!apiKey) {
+        return res.status(400).json({ error: 'apiKey is required' });
+    }
+    if (!userKey) {
+        return res.status(401).json({ error: 'userKey is required' });
+    }
+    try {
+        const feedService = new FeedService(req.adminizer);
+        // Find filter by apiKey
+        Adminizer.log.debug(`Feed: looking for filter with apiKey=${apiKey}`);
+        const filter = await feedService.findFilterByApiKey(apiKey);
+        if (!filter) {
+            return res.status(404).json({
+                error: 'Filter not found or API access is disabled',
+                message: 'Check your apiKey or ensure API access is enabled for this filter'
+            });
+        }
+        // Authenticate user by userKey
+        if (!req.adminizer.config.auth.enable) {
+            return res.status(403).json({ error: 'Auth is required for feed access' });
+        }
+        const user = await req.adminizer.modelHandler
+            .internal("feed")
+            .get("UserAP")
+            .findOne({ where: { apiKey: userKey } });
+        if (!user) {
+            return res.status(403).json({ error: 'Invalid userKey' });
+        }
+        Adminizer.log.info(`Feed access: filter "${filter.name}" (${filter.modelName}) by user ${user.login} via ${exportFormat}`);
+        Adminizer.log.debug(`Feed: filter conditions type=${typeof filter.conditions}, isArray=${Array.isArray(filter.conditions)}`);
+        // Generate feed based on format
+        if (exportFormat === 'json') {
+            const data = await feedService.generateJsonFeed(filter, req.adminizer, user);
+            res.setHeader('Content-Type', 'application/json; charset=utf-8');
+            // inline — отображать в браузере вместо скачивания
+            res.setHeader('Content-Disposition', `inline; filename="${filter.modelName}_feed.json"`);
+            return res.json(data);
+        }
+        else {
+            const xml = await feedService.generateAtomFeed(filter, req.adminizer, user);
+            res.setHeader('Content-Type', 'application/atom+xml; charset=utf-8');
+            // inline — отображать в браузере вместо скачивания
+            res.setHeader('Content-Disposition', `inline; filename="${filter.modelName}_feed.xml"`);
+            return res.send(xml);
+        }
+    }
+    catch (error) {
+        console.error('Feed export error:', error);
+        console.error('Stack:', error?.stack);
+        if (error?.cause) {
+            console.error('Cause:', error.cause);
+        }
+        return res.status(500).json({
+            error: 'Failed to generate feed',
+            message: error?.message || 'Unknown error'
+        });
+    }
+}

package/controllers/feedback/feedbackController.d.ts

@@ -1,2 +1,2 @@
 import { Adminizer } from '../../lib/Adminizer';
-export declare function bindFeedbackController(adminizer: Adminizer, policies: MiddlewareType[]): void;
+export declare function bindFeedbackController(adminizer: Adminizer, middlewares: MiddlewareType[]): void;

package/controllers/feedback/feedbackController.js

@@ -1,19 +1,17 @@
 import multer from 'multer';
 import { Adminizer } from '../../lib/Adminizer.js';
+import { requireAuthAPI } from '../../policies/authPolicies.js';
+import { bindWithMiddlewares } from '../../system/routePolicies.js';
 const MAX_FILE_SIZE = 5 * 1024 * 1024; // 5 MB
 const upload = multer({
     storage: multer.memoryStorage(),
     limits: { fileSize: MAX_FILE_SIZE },
 });
-export function bindFeedbackController(adminizer, policies) {
-    const { app, config, policyManager } = adminizer;
+export function bindFeedbackController(adminizer, middlewares) {
+    const { app, config } = adminizer;
     const prefix = config.routePrefix;
     const uploadMiddleware = upload.array('files', 10);
     const handler = async (req, res) => {
-        if (adminizer.config.auth?.enable && !req.user) {
-            res.status(401).json({ error: req.i18n.__('Unauthorized') });
-            return;
-        }
         uploadMiddleware(req, res, async (err) => {
             if (err) {
                 if (err.code === 'LIMIT_FILE_SIZE') {
@@ -63,5 +61,5 @@ export function bindFeedbackController(adminizer, policies) {
             }
         });
     };
-    app.post(`${prefix}/api/feedback`, ...policyManager.bindPolicies(policies, handler));
+    app.post(`${prefix}/api/feedback`, ...bindWithMiddlewares(adminizer, middlewares, handler, [requireAuthAPI()]));
 }

package/controllers/filter-fields/columns.d.ts

@@ -0,0 +1,11 @@
+/**
+ * GET /adminizer/model/:model/columns
+ * Returns available columns for the model (considering DataAccessor rights)
+ * Also returns columns for a specific filter if filterId is provided
+ */
+export declare function getModelColumns(req: ReqType, res: ResType): Promise<ResType>;
+/**
+ * POST /adminizer/model/:model/filter/:filterId/columns
+ * Update column configuration for a specific filter
+ */
+export declare function updateFilterColumns(req: ReqType, res: ResType): Promise<ResType>;

package/controllers/filter-fields/columns.js

@@ -0,0 +1,106 @@
+import { ControllerHelper } from "../../helpers/controllerHelper.js";
+import { DataAccessor } from "../../lib/DataAccessor.js";
+import { FilterService } from "../../lib/filters/FilterService.js";
+/**
+ * GET /adminizer/model/:model/columns
+ * Returns available columns for the model (considering DataAccessor rights)
+ * Also returns columns for a specific filter if filterId is provided
+ */
+export async function getModelColumns(req, res) {
+    const modelResource = ControllerHelper.findModelResource(req);
+    if (!modelResource.model) {
+        return res.status(404).send({ error: req.i18n.__('Model not found') });
+    }
+    // Get available fields from DataAccessor (respects user permissions)
+    const dataAccessor = new DataAccessor(req.adminizer, req.user, modelResource, "list");
+    const fields = dataAccessor.getFieldsConfig();
+    // Convert fields to column format
+    const availableColumns = Object.entries(fields).map(([fieldName, field]) => {
+        // Get label and type from config
+        const config = typeof field.config === 'object' ? field.config : null;
+        const label = config?.title || fieldName;
+        const type = config?.type || 'string';
+        return {
+            fieldName,
+            label,
+            type,
+            order: 0
+        };
+    });
+    // If filterId provided, also return filter's column configuration
+    const filterId = req.query.filterId ? req.query.filterId.toString() : undefined;
+    let filterColumns = [];
+    if (filterId && filterId !== 'temporary') {
+        try {
+            const filterService = new FilterService(req.adminizer);
+            const result = await filterService.getFilterWithColumns(filterId, req.user);
+            if (result.filter) {
+                filterColumns = result.columns;
+            }
+        }
+        catch (err) {
+            // Ignore errors, return available columns without filter config
+        }
+    }
+    else if (filterId === 'temporary') {
+        // Get temporary filter columns from session
+        if (req.session?.temporaryFilters?.[modelResource.name]?.columns) {
+            const tempColumns = req.session.temporaryFilters[modelResource.name].columns;
+            filterColumns = tempColumns.map((col, index) => ({
+                id: index + 1,
+                filter: 'temporary',
+                fieldName: col.fieldName,
+                order: col.order !== undefined ? col.order : index
+            }));
+        }
+    }
+    return res.json({
+        model: modelResource.name,
+        availableColumns,
+        filterColumns: filterColumns,
+        hasFilterConfig: filterColumns.length > 0
+    });
+}
+/**
+ * POST /adminizer/model/:model/filter/:filterId/columns
+ * Update column configuration for a specific filter
+ */
+export async function updateFilterColumns(req, res) {
+    const modelResource = ControllerHelper.findModelResource(req);
+    if (!modelResource.model) {
+        return res.status(404).send({ error: req.i18n.__('Model not found') });
+    }
+    const filterId = req.params.filterId ? String(req.params.filterId) : undefined;
+    if (!filterId) {
+        return res.status(400).send({ error: req.i18n.__('Filter ID is required') });
+    }
+    const { columns } = req.body;
+    if (!columns || !Array.isArray(columns)) {
+        return res.status(400).send({ error: req.i18n.__('Columns array is required') });
+    }
+    const filterService = new FilterService(req.adminizer);
+    try {
+        // Validate filter exists and user has access
+        const filter = await filterService.getFilterById(filterId, req.user);
+        if (!filter) {
+            return res.status(404).send({ error: req.i18n.__('Filter not found or access denied') });
+        }
+        // Convert frontend column format to FilterColumnAP format
+        const filterColumns = columns.map((col, index) => ({
+            fieldName: col.fieldName,
+            order: col.order !== undefined ? col.order : index
+        }));
+        // Save columns
+        const result = await filterService.updateFilterColumns(filterId, filterColumns, req.user);
+        return res.json({
+            success: true,
+            columns: result
+        });
+    }
+    catch (error) {
+        return res.status(500).json({
+            error: req.i18n.__('Failed to update filter columns'),
+            message: error.message
+        });
+    }
+}

package/controllers/filter-fields/filterFields.d.ts

@@ -0,0 +1,10 @@
+/**
+ * Get filter fields for ANY model
+ *
+ * Takes fields from DataAccessor (merged config + access rights)
+ * Excludes: system fields, complex JSON fields, model-level filters.excludeFromFilters
+ * For Sequelize, includes simple relation filters (association/association-many + simple related fields)
+ *
+ * This controller is universal - works with any model
+ */
+export default function filterFields(req: ReqType, res: ResType): Promise<ResType>;

package/controllers/filter-fields/filterFields.js

@@ -0,0 +1,141 @@
+import { ControllerHelper } from "../../helpers/controllerHelper.js";
+import { DataAccessor } from "../../lib/DataAccessor.js";
+function getFieldType(field) {
+    const cfg = typeof field.config === 'object' && field.config !== null ? field.config : null;
+    return (cfg?.type || field.model?.type || 'string');
+}
+function getFieldLabel(req, fieldName, field) {
+    const cfg = typeof field.config === 'object' && field.config !== null ? field.config : null;
+    return req.i18n.__(cfg?.title || fieldName) || fieldName;
+}
+function getFieldOptions(req, field) {
+    const cfg = typeof field.config === 'object' && field.config !== null ? field.config : null;
+    const type = (cfg?.type || field.model?.type);
+    const isIn = cfg?.isIn;
+    if ((type !== 'select' && type !== 'select-many') || !isIn) {
+        return undefined;
+    }
+    if (Array.isArray(isIn)) {
+        return isIn.map((val) => ({ value: val, label: String(val) }));
+    }
+    if (typeof isIn === 'object') {
+        return Object.entries(isIn).map(([value, label]) => ({
+            value,
+            label: req.i18n.__(String(label)) || String(label),
+        }));
+    }
+    return undefined;
+}
+function isSimpleFilterField(type) {
+    return ![
+        'association',
+        'association-many',
+        'json',
+        'jsoneditor',
+        'object',
+        'array',
+    ].includes(type);
+}
+/**
+ * Get filter fields for ANY model
+ *
+ * Takes fields from DataAccessor (merged config + access rights)
+ * Excludes: system fields, complex JSON fields, model-level filters.excludeFromFilters
+ * For Sequelize, includes simple relation filters (association/association-many + simple related fields)
+ *
+ * This controller is universal - works with any model
+ */
+export default async function filterFields(req, res) {
+    const modelResource = ControllerHelper.findModelResource(req);
+    if (!modelResource.model) {
+        return res.status(404).send({ error: req.i18n.__('Model not found') });
+    }
+    // Get fields via DataAccessor (respects access rights and merged field config)
+    const dataAccessor = new DataAccessor(req.adminizer, req.user, modelResource, "list");
+    const fields = dataAccessor.getFieldsConfig() || {};
+    // Get filter config for this model (optional)
+    // Preferred: model-level `models.<Model>.filters`; fallback: legacy top-level `modelFilters.<Model>`
+    const filterConfig = modelResource.config?.filters ?? req.adminizer.config.modelFilters?.[modelResource.name];
+    const filterFields = [];
+    for (const [fieldName, field] of Object.entries(fields)) {
+        const type = getFieldType(field);
+        const cfg = typeof field.config === 'object' && field.config !== null ? field.config : null;
+        const customFilterHandlerId = cfg?.customFilter?.handlerId
+            ? String(cfg.customFilter.handlerId)
+            : undefined;
+        const customFilterHandler = customFilterHandlerId
+            ? req.adminizer.customFilterHandler?.get(customFilterHandlerId)
+            : undefined;
+        const customFilter = customFilterHandlerId
+            ? {
+                handlerId: customFilterHandlerId,
+                conditionLabel: customFilterHandler?.name
+                    || (cfg?.customFilter?.label ? String(cfg.customFilter.label) : undefined)
+                    || customFilterHandlerId,
+                inputConfig: customFilterHandler?.inputConfig,
+            }
+            : null;
+        // Skip model-specific excluded fields
+        if (filterConfig?.excludeFromFilters?.includes(fieldName)) {
+            continue;
+        }
+        // Skip system fields (universal rule for all models)
+        if (fieldName === 'id' || fieldName === 'ownerId' || fieldName === 'updatedAt') {
+            continue;
+        }
+        const isRelationField = type === 'association' || type === 'association-many';
+        // Base (non-relation) fields
+        if (!isRelationField) {
+            if (!isSimpleFilterField(type) && !customFilter) {
+                continue;
+            }
+            filterFields.push({
+                id: fieldName,
+                label: getFieldLabel(req, fieldName, field),
+                type,
+                isCustomFilter: Boolean(customFilter),
+                customFilterHandlerId: customFilter?.handlerId,
+                customFilterConditionLabel: customFilter?.conditionLabel,
+                customFilterInputConfig: customFilter?.inputConfig,
+                required: Boolean((typeof field.config === 'object' && field.config !== null ? field.config.required : false)),
+                options: getFieldOptions(req, field),
+            });
+            continue;
+        }
+        const ormType = req.adminizer.ormAdapters?.[0]?.ormType;
+        const isSequelize = ormType === 'sequelize';
+        // Relations in filter UI are supported only for Sequelize
+        if (!isSequelize) {
+            continue;
+        }
+        // Include relation with only simple fields of related model
+        const relationFields = Object.entries(field.populated || {})
+            .map(([relatedFieldName, relatedField]) => {
+            const relatedType = getFieldType(relatedField);
+            if (!isSimpleFilterField(relatedType)) {
+                return null;
+            }
+            return {
+                id: relatedFieldName,
+                label: getFieldLabel(req, relatedFieldName, relatedField),
+                type: relatedType,
+                options: getFieldOptions(req, relatedField),
+            };
+        })
+            .filter((item) => !!item);
+        if (relationFields.length === 0) {
+            continue;
+        }
+        filterFields.push({
+            id: fieldName,
+            label: getFieldLabel(req, fieldName, field),
+            type,
+            isRelation: true,
+            relationFields,
+        });
+    }
+    return res.json({
+        model: modelResource.name,
+        fields: filterFields,
+    });
+}

package/controllers/filter-fields/getAllUserFilters.d.ts

@@ -0,0 +1,6 @@
+/**
+ * GET /adminizer/api/all-user-filters
+ * Returns all filters accessible to the current user across all models.
+ * Supports search by name, filter by modelName, and pagination.
+ */
+export declare function getAllUserFilters(req: ReqType, res: ResType): Promise<ResType>;

package/controllers/filter-fields/getAllUserFilters.js

@@ -0,0 +1,115 @@
+import { FilterService } from "../../lib/filters/FilterService.js";
+import { Adminizer } from "../../lib/Adminizer.js";
+/**
+ * GET /adminizer/api/all-user-filters
+ * Returns all filters accessible to the current user across all models.
+ * Supports search by name, filter by modelName, and pagination.
+ */
+export async function getAllUserFilters(req, res) {
+    const filterService = new FilterService(req.adminizer);
+    const userModel = req.adminizer.modelHandler.model.get('userap');
+    const groupModel = req.adminizer.modelHandler.model.get('groupap');
+    // Cache for group names: { groupId: groupName }
+    const groupNamesCache = {};
+    const getGroupName = async (groupId) => {
+        if (groupNamesCache[groupId])
+            return groupNamesCache[groupId];
+        try {
+            const group = await groupModel?.['_findOne']({ where: { id: groupId } });
+            if (group) {
+                groupNamesCache[groupId] = group.name || String(groupId);
+                return groupNamesCache[groupId];
+            }
+        }
+        catch (e) { /* ignore */ }
+        groupNamesCache[groupId] = String(groupId);
+        return groupNamesCache[groupId];
+    };
+    // Extract query parameters
+    const search = typeof req.query.search === 'string' ? req.query.search : undefined;
+    const modelNameFilter = typeof req.query.modelName === 'string' ? req.query.modelName : undefined;
+    const offset = parseInt(String(req.query.offset || 0), 10) || 0;
+    const limit = parseInt(String(req.query.limit || 50), 10) || 50;
+    // Get all models from config
+    const allModels = req.adminizer.config.models || {};
+    const modelNames = Object.keys(allModels);
+    // Determine which models to query
+    const modelsToQuery = modelNameFilter
+        ? modelNames.filter(name => name === modelNameFilter)
+        : modelNames;
+    // Collect all filters from all models
+    const allFilters = [];
+    for (const modelName of modelsToQuery) {
+        try {
+            const filters = await filterService.getFiltersForModel(modelName, req.user, {
+                includePublic: true,
+                includeSystem: false
+            });
+            const modelConfig = allModels[modelName];
+            const modelTitle = modelConfig?.title || modelName;
+            for (const filter of filters) {
+                // Load owner info
+                let ownerName;
+                if (userModel && filter.ownerId) {
+                    try {
+                        const owner = await userModel['_findOne']({ where: { id: filter.ownerId } });
+                        if (owner) {
+                            ownerName = owner.fullName || owner.login || String(owner.id);
+                        }
+                    }
+                    catch (e) {
+                        // Ignore owner load errors
+                    }
+                }
+                // Load group names for 'groups' visibility
+                let groupNames;
+                if (filter.visibility === 'groups' && filter.groupIds && filter.groupIds.length > 0) {
+                    groupNames = [];
+                    for (const gid of filter.groupIds) {
+                        const gName = await getGroupName(gid);
+                        groupNames.push(gName);
+                    }
+                }
+                allFilters.push({
+                    id: filter.id,
+                    name: filter.name,
+                    modelName: filter.modelName,
+                    modelTitle,
+                    visibility: filter.visibility,
+                    apiEnabled: filter.apiEnabled === true,
+                    ownerId: filter.ownerId,
+                    ownerName,
+                    isOwner: filter.ownerId === req.user?.id,
+                    groupNames
+                });
+            }
+        }
+        catch (e) {
+            Adminizer.log.debug(`Error loading filters for model ${modelName}:`, e);
+        }
+    }
+    // Apply search filter (by name, case-insensitive)
+    let filteredFilters = allFilters;
+    if (search) {
+        const searchLower = search.toLowerCase();
+        filteredFilters = allFilters.filter(f => f.name.toLowerCase().includes(searchLower));
+    }
+    // Calculate pagination
+    const total = filteredFilters.length;
+    const paginatedFilters = filteredFilters.slice(offset, offset + limit);
+    const hasMore = offset + limit < total;
+    // Build models list for frontend dropdown
+    const modelsList = modelNames.map(name => {
+        const config = allModels[name];
+        return {
+            name,
+            title: config?.title || name
+        };
+    });
+    return res.json({
+        filters: paginatedFilters,
+        models: modelsList,
+        total,
+        hasMore
+    });
+}

package/controllers/filter-fields/groups.d.ts

@@ -0,0 +1,5 @@
+/**
+ * GET /adminizer/groups
+ * Returns list of all groups (for filter visibility settings)
+ */
+export declare function getAllGroups(req: ReqType, res: ResType): Promise<ResType>;

package/controllers/filter-fields/groups.js

@@ -0,0 +1,26 @@
+/**
+ * GET /adminizer/groups
+ * Returns list of all groups (for filter visibility settings)
+ */
+export async function getAllGroups(req, res) {
+    try {
+        const groupModel = req.adminizer.modelHandler.model.get('groupap');
+        if (!groupModel) {
+            return res.status(500).send({ error: req.i18n.__('GroupAP model not found') });
+        }
+        const groups = await groupModel['_find']({});
+        return res.json({
+            groups: groups.map((g) => ({
+                id: g.id,
+                name: g.name,
+                description: g.description || ''
+            }))
+        });
+    }
+    catch (error) {
+        return res.status(500).json({
+            error: req.i18n.__('Failed to load groups'),
+            message: error.message
+        });
+    }
+}

package/controllers/filter-fields/savedFilters.d.ts

@@ -0,0 +1,25 @@
+/**
+ * POST /adminizer/model/:model/filter/apply
+ * Apply temporary filter (without saving) - stores filter in session keyed by model name
+ */
+export declare function applyTemporaryFilter(req: ReqType, res: ResType): Promise<ResType>;
+/**
+ * GET /adminizer/model/:model/filter/temporary
+ * Returns temporary filter from server session.
+ */
+export declare function getTemporaryFilter(req: ReqType, res: ResType): Promise<ResType>;
+/**
+ * GET /adminizer/model/:model/saved-filters
+ * Returns list of saved filters for the model
+ */
+export declare function getSavedFilters(req: ReqType, res: ResType): Promise<ResType>;
+/**
+ * POST /adminizer/model/:model/filter
+ * Create or update a saved filter
+ */
+export declare function saveFilter(req: ReqType, res: ResType): Promise<ResType>;
+/**
+ * DELETE /adminizer/model/:model/filter/:id
+ * Delete a saved filter
+ */
+export declare function deleteFilter(req: ReqType, res: ResType): Promise<ResType>;