Mendix 10: Building & Integrating Apps With External Systems

Enable the marketplace tab, install and import Community Commons and OQL modules from the marketplace, and create an extensions module for reusable microflows and Java actions.

Create a remote object base entity for a quiz app, define attributes (ID, created date, target date, created by, changed by) and establish an account association for orchestration across modules.

Explore implementing a before commit microflow for a Mendix 10 remote object, auto-setting custom created date and custom changed date as long fields for objects and updates, while preventing edits.

Explore inheritance in Mendix using a remote object as base for car and motorcycle, with a shared tax amount, and note the before commit event order.

Explore polymorphism in Mendix 10 by using a remote parent object in microflows to calculate tax amounts for car or motorcycle objects through an object type decision and merging.

Create an anonymous module and anonymous user role, enable anonymous access, and configure a login web page. Test with demo anon and demo user to verify anonymous usage.

Build a conditional register and sign-in form in Mendix 10 using a non-persistent anonymous entity, a data view with visibility rules, and nano flows to switch forms.

Build a sign up form using an anonymous data view, validate name, full name, email with a regular expression, and password confirmation before creating a new account object.

Create a new microflow to register accounts by constructing an anonymous object, hashing the password, assigning a user role, and generating an account ID with loading indicators and error handling.

Install Eclipse and configure it for Mendix, set UTF-8 encoding, verify the Java Development Kit path, and open the Mendix project to locate the user by IP without external API.

Learn how to obtain user location in Mendix without external APIs by using MaxmindDB to map IPs to city and country, integrating Java actions and resources.

Implement city and country logic during registration by creating city and country entities, determining them from IP, ensuring unique records, and linking them to user accounts with correct commit order.

Build a builder module with school, course, and lecture remote entities and before commit logic for created by and changed by, then configure a page with three connected data grids.

Explore Mendix 10 connected grids to implement course and lecture CRUD—create, edit, delete—using modal forms, single selection, and visibility rules with administrator permissions.

Define the data employee role to enter course and lecture data and generate student tests, and enforce that data employees can update and delete only their own data.

Create a data employee role and assign it as a user role, then configure permissions and access rules to let the demo data employee manage courses and lectures.

Enforce owner-based data access in Mendix 10 by using reusable microflows and before commit/delete events, so data employees can only edit or delete their own records.

Implement cascade delete to automatically remove related courses when deleting a school, and remove related lectures when deleting a course; verify the before delete event order.

Build connected dropdowns to select school, course, and lecture data, then use the test builder to navigate questions, save, and create tests with role-based data security.

Generate demo data for a high school schema, including courses and lectures, to power connected selectors and reference dropdowns in Mendix 10; validate object state, create, update, and delete flows.

Build connected dropdowns that filter courses and lectures by the selected school and course, using reference selectors, a data view, a helper object, and microflows to refresh on change.

Mendix 10 fixes bugs in connected selectors by resetting selected course and lecture on school changes, and converting micro flows to nano flow to boost performance.

Create a test builder page inside builder module and add it to navigation with permissions. Implement validation that requires a selected school, course, and lecture before launching the test builder.

Develop the test builder component by creating a test builder helper entity, using data views to switch the interface with a show builder flag, and build tests with associated questions.

Implement next and previous question navigation in the Mendix test builder, adding styled buttons and logic to cycle through ten questions with data refresh.

Create a question form using a bootstrap text editor from marketplace, configure options A, B, C, and D, adjust the layout and labels, and prepare a preview of the questions.

Implement a live question preview by moving the data view into a responsive layout, configure options A–D, and render the question body with a rich text editor and HTML support.

Improve the test builder page user interface by centering selectors, adopting container and card styles, and simplifying options to reduce scrolling and create a cleaner, more usable builder.

Implement a save test function by adding a save button and asynchronous, blocking microflow that commits the test and questions after linking to the selected lecture and course, with validation.

Create a new test and build my tests page in Mendix 10 using a data grid to fetch tests and a template grid to preview questions.

Create and verify page routes by setting up root URLs for home, config, builder, and test pages, and test navigation as an administrator.

Implement entity access rules to ensure data employees see only their records, while administrators see everything. Duplicate domain model rules and apply them to entities and microflows.

Implement edit test logic by adding an edit button that navigates to a test builder page. Pass the test builder helper as a page parameter to enable editing the test.

In Mendix 10, edit questions directly by updating tests, navigating to the related question, and converting micro flow to nano flow for client-side performance without extra requests.

Implement delete operations for tests and associated questions with confirmation prompts, ensure cascading deletion of related questions, and maintain ordered reindexing of remaining questions after deletions.

Build a test solver that lets students select courses and lectures, generates random questions, records and validates answers, and displays a report with time, correct, wrong, empty, and per-question review.

Implement a solver module that fetches random questions from the database, builds a solver test, and presents it to students with roles mapped for administrators and users.

Generate solver tests by building solver questions from builder questions, validating selections, and assembling a solver test with random, non-duplicate questions using micro flows and nano flows.

Implement the test solver feature and display solver questions to users by configuring data sources, active solver version, and question sort, with permissions and preview UI adjustments.

Turn the select interaction into clickable options by wiring onClick events to each option container, apply dynamic classes for the selected state, and update styling to reflect the chosen answer.

Implement spent time logic in the solver module by storing a begin date for each solver question and updating the accumulated seconds when navigating between questions.

Implement a test status attribute for the solver test entity using a status enumeration (started, finished, review) and configure the builder page with connected selectors to drive data views.

implement review mode in mendix 10 by finishing tests, calculating correct, wrong, and empty answers, summarizing results, and enabling post-test review with controlled navigation and status updates.

Implement a test results page in Mendix that displays per-question statistics, including correct, wrong, and empty answer counts, total spent time, and enables navigation to questions with dynamic styling.

Implement the solve tests page to allow reviewing solver tests and display spent time, correct and wrong counts, and status for students.

Implement the review flow for solver tests by creating associations, a test helper, and a connected selector, using microflows to fetch solver questions and navigate to review questions.

Implement color cues for options in results: red for wrong, green for correct, and yellow for empty, with review mode showing the correct answer in red or green.

Fix a dynamic class bug by introducing a solver test parameter via the test helper, wiring it through the context, and applying status checks to hide correct answers.

Learn to implement entity access rules for the student role so each user sees only their own salt tests and questions by using created by equals current user.

Fix a missing feature by wiring lecture association to solver tests and building a connected selector only when the lecture is available, retrieving course and school via associations.

We fix route mistakes on a test page. We write tests and replace the solve tests with the salt test to correct the display.

Learn to generate builder tests by creating a microflow that selects a random lecture, builds a ten-question test with multiple-choice options, and commits tests for data employees.

Generate solver tests and questions from random lectures by assembling tests with associated builder questions and populating data for five users.

Create demo users and generate salt test data for them to use in ORCL mode, assigning roles such as administration account and user, then run the project to populate data.

Explore oql, the object query language in Mendix, and learn how to query large datasets at the database level for performant reporting with group by, aggregates, and charts.

Learn how to create an OQL dataset, map query results to non-persistent entities, and join related data via builder lecture, course, and school associations, with debugging and role setup.

Add utility functions to convert oql query results to json via message definitions and exporters, create converters for empty fields, and measure microflow execution time with logging.

pass parameters to a dataset by mapping a non-persistent entity to a sql query, using an account object parameter and emptiness checks to avoid empty results.

Publish and fetch tests from a database using Mendix 10 rest services, VS Code, and Thunder Client; build a data service and configure export/import mappings with lowercase json fields.

Extend get all builder tests by adding logging and a utility microflow to extract http route names, log start and end times, and measure execution time.

Learn how to use query parameters with OQL by building a rest method that accepts user id and amount, links micro flows, and returns a json response.

Define and use path parameters for school, course, and lecture IDs to construct and fetch educational info, retrieve objects from the database, and export lecture data.

Pass the http request body as a parameter to a rest method, map json to Mendix entities, and post tests with questions using import mapping.

Implement username and password authentication in Mendix 10, define and map roles to module permissions for REST access, and use the current user to auto-assign created records.

Use custom authentication in Mendix 10 with a pre-request middleware flow that validates an access token header, returns a user, or yields 401 unauthorized, and access the swagger docs.

Build a pdf document generation module in Mendix 10, configuring runtime and security, enabling pdf export with templates, microflows, and a downloadable test pdf.

Fix the pdf export quality by setting a min height of 380 pixels and previewing the snippet to enable parametric pdf export. Conclude the lesson with congratulations.