4.15

Elevating No-Code Maturity and Industrial Precision

Version 4.15 marks a strategic turning point in the evolution of P4. We are moving beyond being a "configurable system" to becoming a full-scale no-code platform. This release places professional-grade tools directly into the hands of consultants and power users - handling tasks that previously required dedicated engineering resources.

BREAKING CHANGES (2) - See below

Consultant Self-Service: Integration Without Coding

The largest barrier to rapid implementation has been removed. External system integrations (ERP, MES, or external databases) are no longer a separate world of custom programming.

• Integrated Data Flows: You can now build data imports and integrations directly within the Flow Builder using specialized nodes designed to connect to external sources.

• Beyond 1:1 Mapping: Forget limited CSV imports. You can now pull data from an external database via SQL, iterate through it using Loop nodes, and perform on-the-fly transformations (e.g., converting Integers to Strings), calculate values, or validate data against existing P4 entities.

• Implementation Speed: Simple integrations that used to take multiple iterations between programmers and consultants can now be completed in 10 minutes. Even complex relational mapping is achievable by a consultant in under 40 minutes.

Core Logic Overrides: Instant Platform Power

One of the most significant updates in 4.15 is the ability to bypass hardcoded legacy logic with custom-built flows.

• Custom Mapping: You can now replace existing core P4 processes (e.g., "Create Maintenance Order") with your own custom logic designed in the Flow Builder. By simply mapping the core action to your new flow in the Configuration Studio, the application will execute your tailored process instead of the original one.

• Hybrid Evolution: This feature allows consultants to implement custom requirements anywhere in the application immediately. You no longer have to wait for "monolithic" sections of the code to be officially rebuilt - you can start leveraging the full power of the platform today.

Data Architecture Freedom: Custom Entities & GQL

You are no longer restricted to the core system entities. P4 now adapts to the unique data requirements of every customer.

• Custom Entities & Relationships: Create entities for specialized needs, such as "Tool Loans," or define entirely new links between existing data (e.g., assigning specific materials to a User). What used to be a "paid evolution" handled by developers is now a standard configuration task.

• Load Nodes on Steroids: With new support for GQL (GraphQL) queries within the Load node, you can fetch data from multiple related entities in a single step. Combined with Custom Database Views, you have instant access to complex data structures for your Flow processes.

The UI Evolution: Widgets & Interactive Dialogues

Version 4.15 now slowly opens the UI layer of the platform. In the Production Control module, you are no longer confined to fixed screens.

• Interactive Dialogue Windows: You can now add buttons or tables that, when clicked, trigger fully customizable dialogue windows.

• Multi-Tab Layouts: Dialogues can now feature multiple tabs - allowing an operator to see "General Info" on one tab and "Full History" on another. This ensures a clean, noise-free interface that provides exactly what the user needs at that moment.

Enterprise Governance & Portability: P4 Packages

Moving configurations from DEV to TEST to PROD no longer requires hours of manual "re-clicking".

• P4 Packages (MVP): We are introducing the first version of Packages, allowing you to wrap selected entities, views, and flow processes into a single exportable file. This package can then be seamlessly imported into another environment.

• Versioning & Safety: Flow processes are now fully version-controlled. Every change creates a new version, allowing you to roll back at any time. Support for Draft vs. Published states ensures that unverified logic never reaches live production.

Professional Debugging: Step-by-Step Inspection

Process errors are no longer a mystery. Our new visual debugging suite includes:

• Step-by-Step Tracing: Walk through your logic node-by-node and monitor how data changes within the DataStore in real time.

• Proactive Validation: Nodes with configuration errors are now highlighted and provide specific feedback on exactly which validation rule was not met.

AI-Driven Documentation with Artoo

Our AI assistant, Artoo, is now a deeper, active layer of the platform:

• Flow Execution: Artoo is now capable of directly executing the Flow processes you design in the builder.

• Automated Documentation: With one click, Artoo analyzes your flow and generates both a user-friendly summary and a technical node-by-node breakdown. This ensures your system remains self-explanatory and maintainable without manual effort.

Core Innovation: Multicavity Extrusion Planning

We haven't forgotten our core manufacturing users in the automotive and plastics sectors.

• Multicavity Production Slots: Planning for lines with multi-cavity molds is no longer a nightmare. P4 now supports scheduling where a line produces multiple different products simultaneously (e.g., 2x Product A, 1x Product B, and 3x Product C in a single cycle). The system automatically calculates expected quantities and resource utilization based on cycle times and mold configurations.

How This Release Will Be Positioned Externally

From a customer and partner perspective, 4.15 is about confidence and scale:

• No-code solutions become easier to build, debug, and maintain

• Configurations become portable, reusable, and governable

• The platform becomes ready for larger, more complex deployments

This release intentionally focuses on platform maturity over visible feature count.

Breaking Changes

001 - Application / project namespace configuration

From version 4.15, the backend application / project namespace is no longer hard‑coded.
The application now determines the project namespace automatically from the first PSR‑4 namespace that targets application/backend in composer.json and stores it in the PROJECT_NAMESPACE constant. This value is then used e.g. when generating and loading custom entities.

What changed

• The constant PROJECT_NAMESPACE is now set based on the PSR‑4 autoload configuration in composer.json.

• The namespace obtained from this mapping is propagated into custom entity templates and other project classes.

• This makes it possible to change the namespace of application / project classes (for example from P4F\\EBTT to P4F\\Project) without modifying the core application.

Required checks after upgrade to 4.15

1. Verify PSR‑4 mapping for application/backend in composer.json

   In your project’s composer.json, ensure that there is a PSR‑4 entry pointing to application/backend, for example:

   JSON

   "autoload": {
     "psr-4": {
       "P4F\\Project\\": "application/backend/"
     }
   }

002 - HTTPS-only application access

From version 4.15, the application is available only via HTTPS.
Plain HTTP access is no longer supported and all HTTP requests will stop working after the upgrade.

What changed

• The application now requires HTTPS for all access to the UI and APIs.

• Direct HTTP access (e.g. <http://server/...)> is no longer accepted.

• This affects:

  • End users accessing the web UI.

  • API consumers, integrations and scripts calling HTTP endpoints.

  • Any reverse proxies / load balancers that previously forwarded HTTP traffic without TLS termination.

Required actions before / after upgrade to 4.15

1. Ensure HTTPS is properly configured

   • Configure a valid TLS certificate (on the application server or on a reverse proxy / load balancer in front of it).

   • Verify that the application is reachable via <https://...> from:

     • End users’ browsers.

     • All systems/integrations that call the API.

2. Update URLs from HTTP to HTTPS

   • Update all bookmarks, documentation and environment configuration that use <http://> to use <https://> instead.

   • Check and update:

     • Integration endpoints (webhooks, API clients).

     • Configuration of external systems that call the application.

     • Internal scripts or tools that reference the application URL.

3. Update reverse proxy / load balancer configuration (if applicable)

   • If you use a reverse proxy (e.g. Nginx, Apache, HAProxy, cloud load balancer):

     • Make sure it terminates HTTPS with a valid certificate.

     • Ensure it forwards requests to the application using the correct scheme and headers (X-Forwarded-Proto, etc.), according to your deployment guidelines.

   • Remove any configuration that exposes plain HTTP endpoints directly to users.

Impact of not applying these changes

• Users will not be able to access the application via old <http://> URLs.

• Integrations or scripts that still use HTTP will start failing (connection errors, timeouts).

• Monitoring / health checks configured over HTTP may report the application as unavailable until they are updated to HTTPS.

See also changes from previus version: 4.14 | Breaking Changes