Tasks

Complete the task of the chosen difficulty level for your variant number.

The initial level has an independent in-memory model; the following levels use PostgreSQL and a DAO. All domain fields, invariants, and reports are defined in the problem statement; do not replace them with an abstract “name–value” table that lacks the required behavior.

Variants

Variant 1. IT company projects

1. Initial level. Create a standalone JavaFX application “IT company projects”: projects and employees in a TableView, a local in-memory model. Separate the model and the controller, and implement a list of the main entities and an add form with JavaFX properties. The user enters the specified fields and sees a new row or an error; keep the data in memory and block an invalid action with a binding. Fields: projectId, name, budget in cents, employeeId; assign an employee only to an existing project; the budget is nonnegative; a report of the number of employees per project.

2. Basic level. Create a standalone JavaFX/MVC application “IT company projects” with PostgreSQL: projects and employees in a TableView, a PostgreSQL DAO. Implement an FXML list, an edit form, search through a FilteredList, and TableView sorting. Pass the DAO through the constructor or a controller factory; Run JDBC in a Task. After success, refresh the list; after an error, keep the draft; test Cancel, an unknown id, and a restart. Fields: projectId, name, budget in cents, employeeId; assign an employee only to an existing project; the budget is nonnegative; a report of the number of employees per project.

3. Advanced level. Create a standalone JavaFX/MVC application “IT company projects” on PostgreSQL: projects and employees in a TableView, a PostgreSQL DAO. Separate a DAO interface, a transaction service, FXML controllers, and a property model; implement CRUD, a domain report, Task/Service, a busy state, and protection against repeated clicks. Add --config=path, --report=from:to, and --help for a report without the GUI: an aligned table and totals, errors to stderr, exit codes 0/2/1. Write service tests with a fake and JDBC tests of rollback and keys, and test cancellation and closing of resources; prepare a jpackage artifact and describe the configuration path. Fields: projectId, name, budget in cents, employeeId; assign an employee only to an existing project; the budget is nonnegative; a report of the number of employees per project. The report filters the main records by an added createdOn field (ISO creation date), both bounds inclusive, with from no later than to. The --report parameter without a value prompts for these dates from the keyboard; EOF gives exit code 2.

Variant 2. A school olympiad

1. Initial level. Create a standalone JavaFX application “School olympiad”: participants, jury scores, a ranking through bindings. Separate the model and the controller, and implement a list of the main entities and an add form with JavaFX properties. The user enters the specified fields and sees a new row or an error; keep the data in memory and block an invalid action with a binding. Fields: participantId, name, score 0..100; reject a repeated id; rank by score, then by id; a report of the number of participants and the average.

2. Basic level. Create a standalone JavaFX/MVC application “School olympiad” with PostgreSQL: participants, jury scores, a ranking through bindings. Implement an FXML list, an edit form, search through a FilteredList, and TableView sorting. Pass the DAO through the constructor or a controller factory; Run JDBC in a Task. After success, refresh the list; after an error, keep the draft; test Cancel, an unknown id, and a restart. Fields: participantId, name, score 0..100; reject a repeated id; rank by score, then by id; a report of the number of participants and the average.

3. Advanced level. Create a standalone JavaFX/MVC application “School olympiad” on PostgreSQL: participants, jury scores, a ranking through bindings. Separate a DAO interface, a transaction service, FXML controllers, and a property model; implement CRUD, a domain report, Task/Service, a busy state, and protection against repeated clicks. Add --config=path, --report=from:to, and --help for a report without the GUI: an aligned table and totals, errors to stderr, exit codes 0/2/1. Write service tests with a fake and JDBC tests of rollback and keys, and test cancellation and closing of resources; prepare a jpackage artifact and describe the configuration path. Fields: participantId, name, score 0..100; reject a repeated id; rank by score, then by id; a report of the number of participants and the average. The report filters the main records by an added createdOn field (ISO creation date), both bounds inclusive, with from no later than to. The --report parameter without a value prompts for these dates from the keyboard; EOF gives exit code 2.

Variant 3. An address book

1. Initial level. Create a standalone JavaFX application “Address book”: contacts, FilteredList search, in-memory storage. Separate the model and the controller, and implement a list of the main entities and an add form with JavaFX properties. The user enters the specified fields and sees a new row or an error; keep the data in memory and block an invalid action with a binding. Fields: contactId, name, email; the email is nonempty and unique; search by part of a name; a report of contacts by first letter.

2. Basic level. Create a standalone JavaFX/MVC application “Address book” with PostgreSQL: contacts, FilteredList search, database storage. Implement an FXML list, an edit form, search through a FilteredList, and TableView sorting. Pass the DAO through the constructor or a controller factory; Run JDBC in a Task. After success, refresh the list; after an error, keep the draft; test Cancel, an unknown id, and a restart. Fields: contactId, name, email; the email is nonempty and unique; search by part of a name; a report of contacts by first letter.

3. Advanced level. Create a standalone JavaFX/MVC application “Address book” on PostgreSQL: contacts, FilteredList search, database storage. Separate a DAO interface, a transaction service, FXML controllers, and a property model; implement CRUD, a domain report, Task/Service, a busy state, and protection against repeated clicks. Add --config=path, --report=from:to, and --help for a report without the GUI: an aligned table and totals, errors to stderr, exit codes 0/2/1. Write service tests with a fake and JDBC tests of rollback and keys, and test cancellation and closing of resources; prepare a jpackage artifact and describe the configuration path. Fields: contactId, name, email; the email is nonempty and unique; search by part of a name; a report of contacts by first letter. The report filters the main records by an added createdOn field (ISO creation date), both bounds inclusive, with from no later than to. The --report parameter without a value prompts for these dates from the keyboard; EOF gives exit code 2.

Variant 4. A pastry shop

1. Initial level. Create a standalone JavaFX application “Pastry shop”: cake orders, cost calculation with bindings. Separate the model and the controller, and implement a list of the main entities and an add form with JavaFX properties. The user enters the specified fields and sees a new row or an error; keep the data in memory and block an invalid action with a binding. Fields: orderId, cake name, weight in grams, price per kilogram in cents; the weight is positive; the price is nonnegative; cost rounded HALF_UP; a report of order totals.

2. Basic level. Create a standalone JavaFX/MVC application “Pastry shop” with PostgreSQL: cake orders, cost calculation with bindings. Implement an FXML list, an edit form, search through a FilteredList, and TableView sorting. Pass the DAO through the constructor or a controller factory; Run JDBC in a Task. After success, refresh the list; after an error, keep the draft; test Cancel, an unknown id, and a restart. Fields: orderId, cake name, weight in grams, price per kilogram in cents; the weight is positive; the price is nonnegative; cost rounded HALF_UP; a report of order totals.

3. Advanced level. Create a standalone JavaFX/MVC application “Pastry shop” on PostgreSQL: cake orders, cost calculation with bindings. Separate a DAO interface, a transaction service, FXML controllers, and a property model; implement CRUD, a domain report, Task/Service, a busy state, and protection against repeated clicks. Add --config=path, --report=from:to, and --help for a report without the GUI: an aligned table and totals, errors to stderr, exit codes 0/2/1. Write service tests with a fake and JDBC tests of rollback and keys, and test cancellation and closing of resources; prepare a jpackage artifact and describe the configuration path. Fields: orderId, cake name, weight in grams, price per kilogram in cents; the weight is positive; the price is nonnegative; cost rounded HALF_UP; a report of order totals. The report filters the main records by an added createdOn field (ISO creation date), both bounds inclusive, with from no later than to. The --report parameter without a value prompts for these dates from the keyboard; EOF gives exit code 2.

Variant 5. Personal finance

1. Initial level. Create a standalone JavaFX application “Personal finance”: accounts, transfers in a transaction, an expense chart. Separate the model and the controller, and implement a list of the main entities and an add form with JavaFX properties. The user enters the specified fields and sees a new row or an error; keep the data in memory and block an invalid action with a binding. Fields: accountId, name, balance in cents; a fictional transfer between different accounts cannot make a balance negative; a turnover report, without financial advice.

2. Basic level. Create a standalone JavaFX/MVC application “Personal finance” with PostgreSQL: accounts, transfers in a transaction, an expense chart. Implement an FXML list, an edit form, search through a FilteredList, and TableView sorting. Pass the DAO through the constructor or a controller factory; Run JDBC in a Task. After success, refresh the list; after an error, keep the draft; test Cancel, an unknown id, and a restart. Fields: accountId, name, balance in cents; a fictional transfer between different accounts cannot make a balance negative; a turnover report, without financial advice.

3. Advanced level. Create a standalone JavaFX/MVC application “Personal finance” on PostgreSQL: accounts, transfers in a transaction, an expense chart. Separate a DAO interface, a transaction service, FXML controllers, and a property model; implement CRUD, a domain report, Task/Service, a busy state, and protection against repeated clicks. Add --config=path, --report=from:to, and --help for a report without the GUI: an aligned table and totals, errors to stderr, exit codes 0/2/1. Write service tests with a fake and JDBC tests of rollback and keys, and test cancellation and closing of resources; prepare a jpackage artifact and describe the configuration path. Fields: accountId, name, balance in cents; a fictional transfer between different accounts cannot make a balance negative; a turnover report, without financial advice. The report filters the main records by an added createdOn field (ISO creation date), both bounds inclusive, with from no later than to. The --report parameter without a value prompts for these dates from the keyboard; EOF gives exit code 2.

Variant 6. A bakery

1. Initial level. Create a standalone JavaFX application “Bakery”: products, batches, sales, and daily stock. Separate the model and the controller, and implement a list of the main entities and an add form with JavaFX properties. The user enters the specified fields and sees a new row or an error; keep the data in memory and block an invalid action with a binding. Fields: productId, name, produced, sold; 0 ≤ sold ≤ produced; the sale operation checks the stock; a report of daily stock.

2. Basic level. Create a standalone JavaFX/MVC application “Bakery” with PostgreSQL: products, batches, sales, and daily stock. Implement an FXML list, an edit form, search through a FilteredList, and TableView sorting. Pass the DAO through the constructor or a controller factory; Run JDBC in a Task. After success, refresh the list; after an error, keep the draft; test Cancel, an unknown id, and a restart. Fields: productId, name, produced, sold; 0 ≤ sold ≤ produced; the sale operation checks the stock; a report of daily stock.

3. Advanced level. Create a standalone JavaFX/MVC application “Bakery” on PostgreSQL: products, batches, sales, and daily stock. Separate a DAO interface, a transaction service, FXML controllers, and a property model; implement CRUD, a domain report, Task/Service, a busy state, and protection against repeated clicks. Add --config=path, --report=from:to, and --help for a report without the GUI: an aligned table and totals, errors to stderr, exit codes 0/2/1. Write service tests with a fake and JDBC tests of rollback and keys, and test cancellation and closing of resources; prepare a jpackage artifact and describe the configuration path. Fields: productId, name, produced, sold; 0 ≤ sold ≤ produced; the sale operation checks the stock; a report of daily stock. The report filters the main records by an added createdOn field (ISO creation date), both bounds inclusive, with from no later than to. The --report parameter without a value prompts for these dates from the keyboard; EOF gives exit code 2.

Variant 7. A chess club

1. Initial level. Create a standalone JavaFX application “Chess club”: players, games, Elo rating recalculation. Separate the model and the controller, and implement a list of the main entities and an add form with JavaFX properties. The user enters the specified fields and sees a new row or an error; keep the data in memory and block an invalid action with a binding. Fields: playerId, name, nominal rating, game result 0/0.5/1; different players; the new rating formula is R+20*(S-E), E=1/(1+10^((Rother-R)/400)); a report of games.

2. Basic level. Create a standalone JavaFX/MVC application “Chess club” with PostgreSQL: players, games, Elo rating recalculation. Implement an FXML list, an edit form, search through a FilteredList, and TableView sorting. Pass the DAO through the constructor or a controller factory; Run JDBC in a Task. After success, refresh the list; after an error, keep the draft; test Cancel, an unknown id, and a restart. Fields: playerId, name, nominal rating, game result 0/0.5/1; different players; the new rating formula is R+20*(S-E), E=1/(1+10^((Rother-R)/400)); a report of games.

3. Advanced level. Create a standalone JavaFX/MVC application “Chess club” on PostgreSQL: players, games, Elo rating recalculation. Separate a DAO interface, a transaction service, FXML controllers, and a property model; implement CRUD, a domain report, Task/Service, a busy state, and protection against repeated clicks. Add --config=path, --report=from:to, and --help for a report without the GUI: an aligned table and totals, errors to stderr, exit codes 0/2/1. Write service tests with a fake and JDBC tests of rollback and keys, and test cancellation and closing of resources; prepare a jpackage artifact and describe the configuration path. Fields: playerId, name, nominal rating, game result 0/0.5/1; different players; the new rating formula is R+20*(S-E), E=1/(1+10^((Rother-R)/400)); a report of games. The report filters the main records by an added createdOn field (ISO creation date), both bounds inclusive, with from no later than to. The --report parameter without a value prompts for these dates from the keyboard; EOF gives exit code 2.

Variant 8. A kindergarten

1. Initial level. Create a standalone JavaFX application “Kindergarten”: groups, children, attendance tracking. Separate the model and the controller, and implement a list of the main entities and an add form with JavaFX properties. The user enters the specified fields and sees a new row or an error; keep the data in memory and block an invalid action with a binding. Fields: childId, fictional name, groupId, date present; do not duplicate a child on the same date; synthetic data only; a report of group attendance.

2. Basic level. Create a standalone JavaFX/MVC application “Kindergarten” with PostgreSQL: groups, children, attendance tracking. Implement an FXML list, an edit form, search through a FilteredList, and TableView sorting. Pass the DAO through the constructor or a controller factory; Run JDBC in a Task. After success, refresh the list; after an error, keep the draft; test Cancel, an unknown id, and a restart. Fields: childId, fictional name, groupId, date present; do not duplicate a child on the same date; synthetic data only; a report of group attendance.

3. Advanced level. Create a standalone JavaFX/MVC application “Kindergarten” on PostgreSQL: groups, children, attendance tracking. Separate a DAO interface, a transaction service, FXML controllers, and a property model; implement CRUD, a domain report, Task/Service, a busy state, and protection against repeated clicks. Add --config=path, --report=from:to, and --help for a report without the GUI: an aligned table and totals, errors to stderr, exit codes 0/2/1. Write service tests with a fake and JDBC tests of rollback and keys, and test cancellation and closing of resources; prepare a jpackage artifact and describe the configuration path. Fields: childId, fictional name, groupId, date present; do not duplicate a child on the same date; synthetic data only; a report of group attendance. The report filters the main records by an added createdOn field (ISO creation date), both bounds inclusive, with from no later than to. The --report parameter without a value prompts for these dates from the keyboard; EOF gives exit code 2.

Variant 9. Equipment rental

1. Initial level. Create a standalone JavaFX application “Equipment rental”: skis and tents, rentals, a returns report. Separate the model and the controller, and implement a list of the main entities and an add form with JavaFX properties. The user enters the specified fields and sees a new row or an error; keep the data in memory and block an invalid action with a binding. Fields: itemId, name, issue and return dates; one active rental per item; return no earlier than issue; a report of unreturned items.

2. Basic level. Create a standalone JavaFX/MVC application “Equipment rental” with PostgreSQL: skis and tents, rentals, a returns report. Implement an FXML list, an edit form, search through a FilteredList, and TableView sorting. Pass the DAO through the constructor or a controller factory; Run JDBC in a Task. After success, refresh the list; after an error, keep the draft; test Cancel, an unknown id, and a restart. Fields: itemId, name, issue and return dates; one active rental per item; return no earlier than issue; a report of unreturned items.

3. Advanced level. Create a standalone JavaFX/MVC application “Equipment rental” on PostgreSQL: skis and tents, rentals, a returns report. Separate a DAO interface, a transaction service, FXML controllers, and a property model; implement CRUD, a domain report, Task/Service, a busy state, and protection against repeated clicks. Add --config=path, --report=from:to, and --help for a report without the GUI: an aligned table and totals, errors to stderr, exit codes 0/2/1. Write service tests with a fake and JDBC tests of rollback and keys, and test cancellation and closing of resources; prepare a jpackage artifact and describe the configuration path. Fields: itemId, name, issue and return dates; one active rental per item; return no earlier than issue; a report of unreturned items. The report filters the main records by an added createdOn field (ISO creation date), both bounds inclusive, with from no later than to. The --report parameter without a value prompts for these dates from the keyboard; EOF gives exit code 2.

Variant 10. A task tracker

1. Initial level. Create a standalone JavaFX application “Task tracker”: statuses, deadlines, filters, and sorting. Separate the model and the controller, and implement a list of the main entities and an add form with JavaFX properties. The user enters the specified fields and sees a new row or an error; keep the data in memory and block an invalid action with a binding. Fields: taskId, name, status TODO/DOING/DONE, ISO deadline; reject an empty name; transition to DONE and a report of counts by status.

2. Basic level. Create a standalone JavaFX/MVC application “Task tracker” with PostgreSQL: statuses, deadlines, filters, and sorting. Implement an FXML list, an edit form, search through a FilteredList, and TableView sorting. Pass the DAO through the constructor or a controller factory; Run JDBC in a Task. After success, refresh the list; after an error, keep the draft; test Cancel, an unknown id, and a restart. Fields: taskId, name, status TODO/DOING/DONE, ISO deadline; reject an empty name; transition to DONE and a report of counts by status.

3. Advanced level. Create a standalone JavaFX/MVC application “Task tracker” on PostgreSQL: statuses, deadlines, filters, and sorting. Separate a DAO interface, a transaction service, FXML controllers, and a property model; implement CRUD, a domain report, Task/Service, a busy state, and protection against repeated clicks. Add --config=path, --report=from:to, and --help for a report without the GUI: an aligned table and totals, errors to stderr, exit codes 0/2/1. Write service tests with a fake and JDBC tests of rollback and keys, and test cancellation and closing of resources; prepare a jpackage artifact and describe the configuration path. Fields: taskId, name, status TODO/DOING/DONE, ISO deadline; reject an empty name; transition to DONE and a report of counts by status. The report filters the main records by an added createdOn field (ISO creation date), both bounds inclusive, with from no later than to. The --report parameter without a value prompts for these dates from the keyboard; EOF gives exit code 2.

Variant 11. A dormitory

1. Initial level. Create a standalone JavaFX application “Dormitory”: rooms, check-ins, payments, and free places. Separate the model and the controller, and implement a list of the main entities and an add form with JavaFX properties. The user enters the specified fields and sees a new row or an error; keep the data in memory and block an invalid action with a binding. Fields: roomId, capacity, residentId, check-in date; do not exceed capacity and do not check in a resident twice; a report of free places.

2. Basic level. Create a standalone JavaFX/MVC application “Dormitory” with PostgreSQL: rooms, check-ins, payments, and free places. Implement an FXML list, an edit form, search through a FilteredList, and TableView sorting. Pass the DAO through the constructor or a controller factory; Run JDBC in a Task. After success, refresh the list; after an error, keep the draft; test Cancel, an unknown id, and a restart. Fields: roomId, capacity, residentId, check-in date; do not exceed capacity and do not check in a resident twice; a report of free places.

3. Advanced level. Create a standalone JavaFX/MVC application “Dormitory” on PostgreSQL: rooms, check-ins, payments, and free places. Separate a DAO interface, a transaction service, FXML controllers, and a property model; implement CRUD, a domain report, Task/Service, a busy state, and protection against repeated clicks. Add --config=path, --report=from:to, and --help for a report without the GUI: an aligned table and totals, errors to stderr, exit codes 0/2/1. Write service tests with a fake and JDBC tests of rollback and keys, and test cancellation and closing of resources; prepare a jpackage artifact and describe the configuration path. Fields: roomId, capacity, residentId, check-in date; do not exceed capacity and do not check in a resident twice; a report of free places. The report filters the main records by an added createdOn field (ISO creation date), both bounds inclusive, with from no later than to. The --report parameter without a value prompts for these dates from the keyboard; EOF gives exit code 2.

Variant 12. A podcast catalog

1. Initial level. Create a standalone JavaFX application “Podcast catalog”: episodes, listening, search by topic. Separate the model and the controller, and implement a list of the main entities and an add form with JavaFX properties. The user enters the specified fields and sees a new row or an error; keep the data in memory and block an invalid action with a binding. Fields: episodeId, title, topic, duration in seconds, listened; the duration is positive; mark as listened and a report by topic.

2. Basic level. Create a standalone JavaFX/MVC application “Podcast catalog” with PostgreSQL: episodes, listening, search by topic. Implement an FXML list, an edit form, search through a FilteredList, and TableView sorting. Pass the DAO through the constructor or a controller factory; Run JDBC in a Task. After success, refresh the list; after an error, keep the draft; test Cancel, an unknown id, and a restart. Fields: episodeId, title, topic, duration in seconds, listened; the duration is positive; mark as listened and a report by topic.

3. Advanced level. Create a standalone JavaFX/MVC application “Podcast catalog” on PostgreSQL: episodes, listening, search by topic. Separate a DAO interface, a transaction service, FXML controllers, and a property model; implement CRUD, a domain report, Task/Service, a busy state, and protection against repeated clicks. Add --config=path, --report=from:to, and --help for a report without the GUI: an aligned table and totals, errors to stderr, exit codes 0/2/1. Write service tests with a fake and JDBC tests of rollback and keys, and test cancellation and closing of resources; prepare a jpackage artifact and describe the configuration path. Fields: episodeId, title, topic, duration in seconds, listened; the duration is positive; mark as listened and a report by topic. The report filters the main records by an added createdOn field (ISO creation date), both bounds inclusive, with from no later than to. The --report parameter without a value prompts for these dates from the keyboard; EOF gives exit code 2.

Variant 13. A food diary

1. Initial level. Create a standalone JavaFX application “Food diary”: meals, calories, a weekly chart. Separate the model and the controller, and implement a list of the main entities and an add form with JavaFX properties. The user enters the specified fields and sees a new row or an error; keep the data in memory and block an invalid action with a binding. Fields: entryId, date, name, nonnegative nominal energy; fictional data only; a report of daily totals without dietary or medical advice.

2. Basic level. Create a standalone JavaFX/MVC application “Food diary” with PostgreSQL: meals, calories, a weekly chart. Implement an FXML list, an edit form, search through a FilteredList, and TableView sorting. Pass the DAO through the constructor or a controller factory; Run JDBC in a Task. After success, refresh the list; after an error, keep the draft; test Cancel, an unknown id, and a restart. Fields: entryId, date, name, nonnegative nominal energy; fictional data only; a report of daily totals without dietary or medical advice.

3. Advanced level. Create a standalone JavaFX/MVC application “Food diary” on PostgreSQL: meals, calories, a weekly chart. Separate a DAO interface, a transaction service, FXML controllers, and a property model; implement CRUD, a domain report, Task/Service, a busy state, and protection against repeated clicks. Add --config=path, --report=from:to, and --help for a report without the GUI: an aligned table and totals, errors to stderr, exit codes 0/2/1. Write service tests with a fake and JDBC tests of rollback and keys, and test cancellation and closing of resources; prepare a jpackage artifact and describe the configuration path. Fields: entryId, date, name, nonnegative nominal energy; fictional data only; a report of daily totals without dietary or medical advice. The report filters the main records by an added createdOn field (ISO creation date), both bounds inclusive, with from no later than to. The --report parameter without a value prompts for these dates from the keyboard; EOF gives exit code 2.

Variant 14. A gardener

1. Initial level. Create a standalone JavaFX application “Gardener”: plants, care, a watering calendar with reminders. Separate the model and the controller, and implement a list of the main entities and an add form with JavaFX properties. The user enters the specified fields and sees a new row or an error; keep the data in memory and block an invalid action with a binding. Fields: plantId, name, date of last watering, given interval in days; the interval is positive; compute the next date and a report of overdue plants as of an explicitly given date.

2. Basic level. Create a standalone JavaFX/MVC application “Gardener” with PostgreSQL: plants, care, a watering calendar with reminders. Implement an FXML list, an edit form, search through a FilteredList, and TableView sorting. Pass the DAO through the constructor or a controller factory; Run JDBC in a Task. After success, refresh the list; after an error, keep the draft; test Cancel, an unknown id, and a restart. Fields: plantId, name, date of last watering, given interval in days; the interval is positive; compute the next date and a report of overdue plants as of an explicitly given date.

3. Advanced level. Create a standalone JavaFX/MVC application “Gardener” on PostgreSQL: plants, care, a watering calendar with reminders. Separate a DAO interface, a transaction service, FXML controllers, and a property model; implement CRUD, a domain report, Task/Service, a busy state, and protection against repeated clicks. Add --config=path, --report=from:to, and --help for a report without the GUI: an aligned table and totals, errors to stderr, exit codes 0/2/1. Write service tests with a fake and JDBC tests of rollback and keys, and test cancellation and closing of resources; prepare a jpackage artifact and describe the configuration path. Fields: plantId, name, date of last watering, given interval in days; the interval is positive; compute the next date and a report of overdue plants as of an explicitly given date. The report filters the main records by an added createdOn field (ISO creation date), both bounds inclusive, with from no later than to. The --report parameter without a value prompts for these dates from the keyboard; EOF gives exit code 2.

Variant 15. A language school

1. Initial level. Create a standalone JavaFX application “Language school”: groups, levels, students, and group occupancy. Separate the model and the controller, and implement a list of the main entities and an add form with JavaFX properties. The user enters the specified fields and sees a new row or an error; keep the data in memory and block an invalid action with a binding. Fields: groupId, level enum A1/A2/B1/B2, capacity, studentId; do not exceed capacity; enrollment and an occupancy report.

2. Basic level. Create a standalone JavaFX/MVC application “Language school” with PostgreSQL: groups, levels, students, and group occupancy. Implement an FXML list, an edit form, search through a FilteredList, and TableView sorting. Pass the DAO through the constructor or a controller factory; Run JDBC in a Task. After success, refresh the list; after an error, keep the draft; test Cancel, an unknown id, and a restart. Fields: groupId, level enum A1/A2/B1/B2, capacity, studentId; do not exceed capacity; enrollment and an occupancy report.

3. Advanced level. Create a standalone JavaFX/MVC application “Language school” on PostgreSQL: groups, levels, students, and group occupancy. Separate a DAO interface, a transaction service, FXML controllers, and a property model; implement CRUD, a domain report, Task/Service, a busy state, and protection against repeated clicks. Add --config=path, --report=from:to, and --help for a report without the GUI: an aligned table and totals, errors to stderr, exit codes 0/2/1. Write service tests with a fake and JDBC tests of rollback and keys, and test cancellation and closing of resources; prepare a jpackage artifact and describe the configuration path. Fields: groupId, level enum A1/A2/B1/B2, capacity, studentId; do not exceed capacity; enrollment and an occupancy report. The report filters the main records by an added createdOn field (ISO creation date), both bounds inclusive, with from no later than to. The --report parameter without a value prompts for these dates from the keyboard; EOF gives exit code 2.

Variant 16. An electronic gradebook

1. Initial level. Create a standalone JavaFX application “Electronic gradebook”: grades, averages through Bindings. Separate the model and the controller, and implement a list of the main entities and an add form with JavaFX properties. The user enters the specified fields and sees a new row or an error; keep the data in memory and block an invalid action with a binding. Fields: studentId, subject, score 0..100; add a grade and show the average through a binding; the absence of grades is not the same as zero.

2. Basic level. Create a standalone JavaFX/MVC application “Electronic gradebook” with PostgreSQL: grades, averages through Bindings. Implement an FXML list, an edit form, search through a FilteredList, and TableView sorting. Pass the DAO through the constructor or a controller factory; Run JDBC in a Task. After success, refresh the list; after an error, keep the draft; test Cancel, an unknown id, and a restart. Fields: studentId, subject, score 0..100; add a grade and show the average through a binding; the absence of grades is not the same as zero.

3. Advanced level. Create a standalone JavaFX/MVC application “Electronic gradebook” on PostgreSQL: grades, averages through Bindings. Separate a DAO interface, a transaction service, FXML controllers, and a property model; implement CRUD, a domain report, Task/Service, a busy state, and protection against repeated clicks. Add --config=path, --report=from:to, and --help for a report without the GUI: an aligned table and totals, errors to stderr, exit codes 0/2/1. Write service tests with a fake and JDBC tests of rollback and keys, and test cancellation and closing of resources; prepare a jpackage artifact and describe the configuration path. Fields: studentId, subject, score 0..100; add a grade and show the average through a binding; the absence of grades is not the same as zero. The report filters the main records by an added createdOn field (ISO creation date), both bounds inclusive, with from no later than to. The --report parameter without a value prompts for these dates from the keyboard; EOF gives exit code 2.

Variant 17. A theater

1. Initial level. Create a standalone JavaFX application “Theater”: plays, actors, casting. Separate the model and the controller, and implement a list of the main entities and an add form with JavaFX properties. The user enters the specified fields and sees a new row or an error; keep the data in memory and block an invalid action with a binding. Fields: playId, title, roleId, actorId; a role in a play has at most one current performer; assignment and a report of roles without a performer.

2. Basic level. Create a standalone JavaFX/MVC application “Theater” with PostgreSQL: plays, actors, casting. Implement an FXML list, an edit form, search through a FilteredList, and TableView sorting. Pass the DAO through the constructor or a controller factory; Run JDBC in a Task. After success, refresh the list; after an error, keep the draft; test Cancel, an unknown id, and a restart. Fields: playId, title, roleId, actorId; a role in a play has at most one current performer; assignment and a report of roles without a performer.

3. Advanced level. Create a standalone JavaFX/MVC application “Theater” on PostgreSQL: plays, actors, casting. Separate a DAO interface, a transaction service, FXML controllers, and a property model; implement CRUD, a domain report, Task/Service, a busy state, and protection against repeated clicks. Add --config=path, --report=from:to, and --help for a report without the GUI: an aligned table and totals, errors to stderr, exit codes 0/2/1. Write service tests with a fake and JDBC tests of rollback and keys, and test cancellation and closing of resources; prepare a jpackage artifact and describe the configuration path. Fields: playId, title, roleId, actorId; a role in a play has at most one current performer; assignment and a report of roles without a performer. The report filters the main records by an added createdOn field (ISO creation date), both bounds inclusive, with from no later than to. The --report parameter without a value prompts for these dates from the keyboard; EOF gives exit code 2.

Variant 18. Appliance repair

1. Initial level. Create a standalone JavaFX application “Appliance repair”: receipts, repair statuses, a customer invoice. Separate the model and the controller, and implement a list of the main entities and an add form with JavaFX properties. The user enters the specified fields and sees a new row or an error; keep the data in memory and block an invalid action with a binding. Fields: receiptId, device, status NEW/WORK/DONE, price in cents; the price is nonnegative; a transition to DONE requires a description of the work; a report of completed repairs.

2. Basic level. Create a standalone JavaFX/MVC application “Appliance repair” with PostgreSQL: receipts, repair statuses, a customer invoice. Implement an FXML list, an edit form, search through a FilteredList, and TableView sorting. Pass the DAO through the constructor or a controller factory; Run JDBC in a Task. After success, refresh the list; after an error, keep the draft; test Cancel, an unknown id, and a restart. Fields: receiptId, device, status NEW/WORK/DONE, price in cents; the price is nonnegative; a transition to DONE requires a description of the work; a report of completed repairs.

3. Advanced level. Create a standalone JavaFX/MVC application “Appliance repair” on PostgreSQL: receipts, repair statuses, a customer invoice. Separate a DAO interface, a transaction service, FXML controllers, and a property model; implement CRUD, a domain report, Task/Service, a busy state, and protection against repeated clicks. Add --config=path, --report=from:to, and --help for a report without the GUI: an aligned table and totals, errors to stderr, exit codes 0/2/1. Write service tests with a fake and JDBC tests of rollback and keys, and test cancellation and closing of resources; prepare a jpackage artifact and describe the configuration path. Fields: receiptId, device, status NEW/WORK/DONE, price in cents; the price is nonnegative; a transition to DONE requires a description of the work; a report of completed repairs. The report filters the main records by an added createdOn field (ISO creation date), both bounds inclusive, with from no later than to. The --report parameter without a value prompts for these dates from the keyboard; EOF gives exit code 2.

Variant 19. Software licenses

1. Initial level. Create a standalone JavaFX application “Software licenses”: licenses, validity periods, expiration warnings. Separate the model and the controller, and implement a list of the main entities and an add form with JavaFX properties. The user enters the specified fields and sees a new row or an error; keep the data in memory and block an invalid action with a binding. Fields: licenseId, product, number of seats, ISO expiration date; the seats are positive; a filter of expiration before a given date and a report of active seats.

2. Basic level. Create a standalone JavaFX/MVC application “Software licenses” with PostgreSQL: licenses, validity periods, expiration warnings. Implement an FXML list, an edit form, search through a FilteredList, and TableView sorting. Pass the DAO through the constructor or a controller factory; Run JDBC in a Task. After success, refresh the list; after an error, keep the draft; test Cancel, an unknown id, and a restart. Fields: licenseId, product, number of seats, ISO expiration date; the seats are positive; a filter of expiration before a given date and a report of active seats.

3. Advanced level. Create a standalone JavaFX/MVC application “Software licenses” on PostgreSQL: licenses, validity periods, expiration warnings. Separate a DAO interface, a transaction service, FXML controllers, and a property model; implement CRUD, a domain report, Task/Service, a busy state, and protection against repeated clicks. Add --config=path, --report=from:to, and --help for a report without the GUI: an aligned table and totals, errors to stderr, exit codes 0/2/1. Write service tests with a fake and JDBC tests of rollback and keys, and test cancellation and closing of resources; prepare a jpackage artifact and describe the configuration path. Fields: licenseId, product, number of seats, ISO expiration date; the seats are positive; a filter of expiration before a given date and a report of active seats. The report filters the main records by an added createdOn field (ISO creation date), both bounds inclusive, with from no later than to. The --report parameter without a value prompts for these dates from the keyboard; EOF gives exit code 2.

Variant 20. A driving school

1. Initial level. Create a standalone JavaFX application “Driving school”: trainees, instructors, a lesson schedule. Separate the model and the controller, and implement a list of the main entities and an add form with JavaFX properties. The user enters the specified fields and sees a new row or an error; keep the data in memory and block an invalid action with a binding. Fields: lessonId, traineeId, instructorId, start and end; the end is after the start; an instructor's lessons do not overlap; a report of hours.

2. Basic level. Create a standalone JavaFX/MVC application “Driving school” with PostgreSQL: trainees, instructors, a lesson schedule. Implement an FXML list, an edit form, search through a FilteredList, and TableView sorting. Pass the DAO through the constructor or a controller factory; Run JDBC in a Task. After success, refresh the list; after an error, keep the draft; test Cancel, an unknown id, and a restart. Fields: lessonId, traineeId, instructorId, start and end; the end is after the start; an instructor's lessons do not overlap; a report of hours.

3. Advanced level. Create a standalone JavaFX/MVC application “Driving school” on PostgreSQL: trainees, instructors, a lesson schedule. Separate a DAO interface, a transaction service, FXML controllers, and a property model; implement CRUD, a domain report, Task/Service, a busy state, and protection against repeated clicks. Add --config=path, --report=from:to, and --help for a report without the GUI: an aligned table and totals, errors to stderr, exit codes 0/2/1. Write service tests with a fake and JDBC tests of rollback and keys, and test cancellation and closing of resources; prepare a jpackage artifact and describe the configuration path. Fields: lessonId, traineeId, instructorId, start and end; the end is after the start; an instructor's lessons do not overlap; a report of hours. The report filters the main records by an added createdOn field (ISO creation date), both bounds inclusive, with from no later than to. The --report parameter without a value prompts for these dates from the keyboard; EOF gives exit code 2.

Variant 21. A pet store

1. Initial level. Create a standalone JavaFX application “Pet store”: products, suppliers, restocking orders. Separate the model and the controller, and implement a list of the main entities and an add form with JavaFX properties. The user enters the specified fields and sees a new row or an error; keep the data in memory and block an invalid action with a binding. Fields: productId, name, stock, minimum stock, supplierId; quantities are nonnegative; order the difference up to the minimum and a restocking report.

2. Basic level. Create a standalone JavaFX/MVC application “Pet store” with PostgreSQL: products, suppliers, restocking orders. Implement an FXML list, an edit form, search through a FilteredList, and TableView sorting. Pass the DAO through the constructor or a controller factory; Run JDBC in a Task. After success, refresh the list; after an error, keep the draft; test Cancel, an unknown id, and a restart. Fields: productId, name, stock, minimum stock, supplierId; quantities are nonnegative; order the difference up to the minimum and a restocking report.

3. Advanced level. Create a standalone JavaFX/MVC application “Pet store” on PostgreSQL: products, suppliers, restocking orders. Separate a DAO interface, a transaction service, FXML controllers, and a property model; implement CRUD, a domain report, Task/Service, a busy state, and protection against repeated clicks. Add --config=path, --report=from:to, and --help for a report without the GUI: an aligned table and totals, errors to stderr, exit codes 0/2/1. Write service tests with a fake and JDBC tests of rollback and keys, and test cancellation and closing of resources; prepare a jpackage artifact and describe the configuration path. Fields: productId, name, stock, minimum stock, supplierId; quantities are nonnegative; order the difference up to the minimum and a restocking report. The report filters the main records by an added createdOn field (ISO creation date), both bounds inclusive, with from no later than to. The --report parameter without a value prompts for these dates from the keyboard; EOF gives exit code 2.

Variant 22. Office rental

1. Initial level. Create a standalone JavaFX application “Office rental”: premises, filters by area and price. Separate the model and the controller, and implement a list of the main entities and an add form with JavaFX properties. The user enters the specified fields and sees a new row or an error; keep the data in memory and block an invalid action with a binding. Fields: officeId, area, price in cents, occupied; the area is positive; a filter by area and price, rental of a free office only, a report of free area.

2. Basic level. Create a standalone JavaFX/MVC application “Office rental” with PostgreSQL: premises, filters by area and price. Implement an FXML list, an edit form, search through a FilteredList, and TableView sorting. Pass the DAO through the constructor or a controller factory; Run JDBC in a Task. After success, refresh the list; after an error, keep the draft; test Cancel, an unknown id, and a restart. Fields: officeId, area, price in cents, occupied; the area is positive; a filter by area and price, rental of a free office only, a report of free area.

3. Advanced level. Create a standalone JavaFX/MVC application “Office rental” on PostgreSQL: premises, filters by area and price. Separate a DAO interface, a transaction service, FXML controllers, and a property model; implement CRUD, a domain report, Task/Service, a busy state, and protection against repeated clicks. Add --config=path, --report=from:to, and --help for a report without the GUI: an aligned table and totals, errors to stderr, exit codes 0/2/1. Write service tests with a fake and JDBC tests of rollback and keys, and test cancellation and closing of resources; prepare a jpackage artifact and describe the configuration path. Fields: officeId, area, price in cents, occupied; the area is positive; a filter by area and price, rental of a free office only, a report of free area. The report filters the main records by an added createdOn field (ISO creation date), both bounds inclusive, with from no later than to. The --report parameter without a value prompts for these dates from the keyboard; EOF gives exit code 2.

Variant 23. A board game club

1. Initial level. Create a standalone JavaFX application “Board game club”: games, meetups, participant sign-ups. Separate the model and the controller, and implement a list of the main entities and an add form with JavaFX properties. The user enters the specified fields and sees a new row or an error; keep the data in memory and block an invalid action with a binding. Fields: meetingId, game title, date, capacity, memberId; do not duplicate a participant and do not exceed capacity; a report of free places at meetups.

2. Basic level. Create a standalone JavaFX/MVC application “Board game club” with PostgreSQL: games, meetups, participant sign-ups. Implement an FXML list, an edit form, search through a FilteredList, and TableView sorting. Pass the DAO through the constructor or a controller factory; Run JDBC in a Task. After success, refresh the list; after an error, keep the draft; test Cancel, an unknown id, and a restart. Fields: meetingId, game title, date, capacity, memberId; do not duplicate a participant and do not exceed capacity; a report of free places at meetups.

3. Advanced level. Create a standalone JavaFX/MVC application “Board game club” on PostgreSQL: games, meetups, participant sign-ups. Separate a DAO interface, a transaction service, FXML controllers, and a property model; implement CRUD, a domain report, Task/Service, a busy state, and protection against repeated clicks. Add --config=path, --report=from:to, and --help for a report without the GUI: an aligned table and totals, errors to stderr, exit codes 0/2/1. Write service tests with a fake and JDBC tests of rollback and keys, and test cancellation and closing of resources; prepare a jpackage artifact and describe the configuration path. Fields: meetingId, game title, date, capacity, memberId; do not duplicate a participant and do not exceed capacity; a report of free places at meetups. The report filters the main records by an added createdOn field (ISO creation date), both bounds inclusive, with from no later than to. The --report parameter without a value prompts for these dates from the keyboard; EOF gives exit code 2.

Variant 24. A medical laboratory

1. Initial level. Create a standalone JavaFX application “Medical laboratory”: samples, results, flagging out-of-range values. Separate the model and the controller, and implement a list of the main entities and an add form with JavaFX properties. The user enters the specified fields and sees a new row or an error; keep the data in memory and block an invalid action with a binding. Fields: sampleId, fictional label, finite value, given training lower and upper bounds; the lower bound is not greater than the upper bound; flag values outside the interval without medical conclusions; a report of counts.

2. Basic level. Create a standalone JavaFX/MVC application “Medical laboratory” with PostgreSQL: samples, results, flagging out-of-range values. Implement an FXML list, an edit form, search through a FilteredList, and TableView sorting. Pass the DAO through the constructor or a controller factory; Run JDBC in a Task. After success, refresh the list; after an error, keep the draft; test Cancel, an unknown id, and a restart. Fields: sampleId, fictional label, finite value, given training lower and upper bounds; the lower bound is not greater than the upper bound; flag values outside the interval without medical conclusions; a report of counts.

3. Advanced level. Create a standalone JavaFX/MVC application “Medical laboratory” on PostgreSQL: samples, results, flagging out-of-range values. Separate a DAO interface, a transaction service, FXML controllers, and a property model; implement CRUD, a domain report, Task/Service, a busy state, and protection against repeated clicks. Add --config=path, --report=from:to, and --help for a report without the GUI: an aligned table and totals, errors to stderr, exit codes 0/2/1. Write service tests with a fake and JDBC tests of rollback and keys, and test cancellation and closing of resources; prepare a jpackage artifact and describe the configuration path. Fields: sampleId, fictional label, finite value, given training lower and upper bounds; the lower bound is not greater than the upper bound; flag values outside the interval without medical conclusions; a report of counts. The report filters the main records by an added createdOn field (ISO creation date), both bounds inclusive, with from no later than to. The --report parameter without a value prompts for these dates from the keyboard; EOF gives exit code 2.

Variant 25. A volunteer center

1. Initial level. Create a standalone JavaFX application “Volunteer center”: volunteers, shifts, task assignment. Separate the model and the controller, and implement a list of the main entities and an add form with JavaFX properties. The user enters the specified fields and sees a new row or an error; keep the data in memory and block an invalid action with a binding. Fields: shiftId, date, capacity, volunteerId, task; do not assign a volunteer to a shift twice and do not exceed capacity; a report of unfilled shifts.

2. Basic level. Create a standalone JavaFX/MVC application “Volunteer center” with PostgreSQL: volunteers, shifts, task assignment. Implement an FXML list, an edit form, search through a FilteredList, and TableView sorting. Pass the DAO through the constructor or a controller factory; Run JDBC in a Task. After success, refresh the list; after an error, keep the draft; test Cancel, an unknown id, and a restart. Fields: shiftId, date, capacity, volunteerId, task; do not assign a volunteer to a shift twice and do not exceed capacity; a report of unfilled shifts.

3. Advanced level. Create a standalone JavaFX/MVC application “Volunteer center” on PostgreSQL: volunteers, shifts, task assignment. Separate a DAO interface, a transaction service, FXML controllers, and a property model; implement CRUD, a domain report, Task/Service, a busy state, and protection against repeated clicks. Add --config=path, --report=from:to, and --help for a report without the GUI: an aligned table and totals, errors to stderr, exit codes 0/2/1. Write service tests with a fake and JDBC tests of rollback and keys, and test cancellation and closing of resources; prepare a jpackage artifact and describe the configuration path. Fields: shiftId, date, capacity, volunteerId, task; do not assign a volunteer to a shift twice and do not exceed capacity; a report of unfilled shifts. The report filters the main records by an added createdOn field (ISO creation date), both bounds inclusive, with from no later than to. The --report parameter without a value prompts for these dates from the keyboard; EOF gives exit code 2.

Variant 26. Recruitment

1. Initial level. Create a standalone JavaFX application “Recruitment”: vacancies, candidates, interview stages. Separate the model and the controller, and implement a list of the main entities and an add form with JavaFX properties. The user enters the specified fields and sees a new row or an error; keep the data in memory and block an invalid action with a binding. Fields: vacancyId, title, candidateId, stage NEW/INTERVIEW/OFFER/REJECTED; one application per candidate per vacancy; change the stage and a report by stage.

2. Basic level. Create a standalone JavaFX/MVC application “Recruitment” with PostgreSQL: vacancies, candidates, interview stages. Implement an FXML list, an edit form, search through a FilteredList, and TableView sorting. Pass the DAO through the constructor or a controller factory; Run JDBC in a Task. After success, refresh the list; after an error, keep the draft; test Cancel, an unknown id, and a restart. Fields: vacancyId, title, candidateId, stage NEW/INTERVIEW/OFFER/REJECTED; one application per candidate per vacancy; change the stage and a report by stage.

3. Advanced level. Create a standalone JavaFX/MVC application “Recruitment” on PostgreSQL: vacancies, candidates, interview stages. Separate a DAO interface, a transaction service, FXML controllers, and a property model; implement CRUD, a domain report, Task/Service, a busy state, and protection against repeated clicks. Add --config=path, --report=from:to, and --help for a report without the GUI: an aligned table and totals, errors to stderr, exit codes 0/2/1. Write service tests with a fake and JDBC tests of rollback and keys, and test cancellation and closing of resources; prepare a jpackage artifact and describe the configuration path. Fields: vacancyId, title, candidateId, stage NEW/INTERVIEW/OFFER/REJECTED; one application per candidate per vacancy; change the stage and a report by stage. The report filters the main records by an added createdOn field (ISO creation date), both bounds inclusive, with from no later than to. The --report parameter without a value prompts for these dates from the keyboard; EOF gives exit code 2.

Variant 27. A study glossary

1. Initial level. Create a standalone JavaFX application “Study glossary”: terms, categories, flashcard mode. Separate the model and the controller, and implement a list of the main entities and an add form with JavaFX properties. The user enters the specified fields and sees a new row or an error; keep the data in memory and block an invalid action with a binding. Fields: termId, term, definition, category; the term is nonempty and unique; show/hide a card's definition and a report of counts by category.

2. Basic level. Create a standalone JavaFX/MVC application “Study glossary” with PostgreSQL: terms, categories, flashcard mode. Implement an FXML list, an edit form, search through a FilteredList, and TableView sorting. Pass the DAO through the constructor or a controller factory; Run JDBC in a Task. After success, refresh the list; after an error, keep the draft; test Cancel, an unknown id, and a restart. Fields: termId, term, definition, category; the term is nonempty and unique; show/hide a card's definition and a report of counts by category.

3. Advanced level. Create a standalone JavaFX/MVC application “Study glossary” on PostgreSQL: terms, categories, flashcard mode. Separate a DAO interface, a transaction service, FXML controllers, and a property model; implement CRUD, a domain report, Task/Service, a busy state, and protection against repeated clicks. Add --config=path, --report=from:to, and --help for a report without the GUI: an aligned table and totals, errors to stderr, exit codes 0/2/1. Write service tests with a fake and JDBC tests of rollback and keys, and test cancellation and closing of resources; prepare a jpackage artifact and describe the configuration path. Fields: termId, term, definition, category; the term is nonempty and unique; show/hide a card's definition and a report of counts by category. The report filters the main records by an added createdOn field (ISO creation date), both bounds inclusive, with from no later than to. The --report parameter without a value prompts for these dates from the keyboard; EOF gives exit code 2.

Variant 28. Weather observations

1. Initial level. Create a standalone JavaFX application “Weather observations”: measurements, LineChart, CSV import. Separate the model and the controller, and implement a list of the main entities and an add form with JavaFX properties. The user enters the specified fields and sees a new row or an error; keep the data in memory and block an invalid action with a binding. Fields: measureId, ISO date, finite temperature; a unique date; CSV import that reports invalid lines, a LineChart, and a min/max/mean report.

2. Basic level. Create a standalone JavaFX/MVC application “Weather observations” with PostgreSQL: measurements, LineChart, CSV import. Implement an FXML list, an edit form, search through a FilteredList, and TableView sorting. Pass the DAO through the constructor or a controller factory; Run JDBC in a Task. After success, refresh the list; after an error, keep the draft; test Cancel, an unknown id, and a restart. Fields: measureId, ISO date, finite temperature; a unique date; CSV import that reports invalid lines, a LineChart, and a min/max/mean report.

3. Advanced level. Create a standalone JavaFX/MVC application “Weather observations” on PostgreSQL: measurements, LineChart, CSV import. Separate a DAO interface, a transaction service, FXML controllers, and a property model; implement CRUD, a domain report, Task/Service, a busy state, and protection against repeated clicks. Add --config=path, --report=from:to, and --help for a report without the GUI: an aligned table and totals, errors to stderr, exit codes 0/2/1. Write service tests with a fake and JDBC tests of rollback and keys, and test cancellation and closing of resources; prepare a jpackage artifact and describe the configuration path. Fields: measureId, ISO date, finite temperature; a unique date; CSV import that reports invalid lines, a LineChart, and a min/max/mean report. The report filters the main records by an added createdOn field (ISO creation date), both bounds inclusive, with from no later than to. The --report parameter without a value prompts for these dates from the keyboard; EOF gives exit code 2.

Variant 29. A coin collection

1. Initial level. Create a standalone JavaFX application “Coin collection”: coins, countries, collection value estimate. Separate the model and the controller, and implement a list of the main entities and an add form with JavaFX properties. The user enters the specified fields and sees a new row or an error; keep the data in memory and block an invalid action with a binding. Fields: coinId, country, year 1..2100, estimate in cents; the estimate is nonnegative; a country filter and a report of the total nominal estimate without investment advice.

2. Basic level. Create a standalone JavaFX/MVC application “Coin collection” with PostgreSQL: coins, countries, collection value estimate. Implement an FXML list, an edit form, search through a FilteredList, and TableView sorting. Pass the DAO through the constructor or a controller factory; Run JDBC in a Task. After success, refresh the list; after an error, keep the draft; test Cancel, an unknown id, and a restart. Fields: coinId, country, year 1..2100, estimate in cents; the estimate is nonnegative; a country filter and a report of the total nominal estimate without investment advice.

3. Advanced level. Create a standalone JavaFX/MVC application “Coin collection” on PostgreSQL: coins, countries, collection value estimate. Separate a DAO interface, a transaction service, FXML controllers, and a property model; implement CRUD, a domain report, Task/Service, a busy state, and protection against repeated clicks. Add --config=path, --report=from:to, and --help for a report without the GUI: an aligned table and totals, errors to stderr, exit codes 0/2/1. Write service tests with a fake and JDBC tests of rollback and keys, and test cancellation and closing of resources; prepare a jpackage artifact and describe the configuration path. Fields: coinId, country, year 1..2100, estimate in cents; the estimate is nonnegative; a country filter and a report of the total nominal estimate without investment advice. The report filters the main records by an added createdOn field (ISO creation date), both bounds inclusive, with from no later than to. The --report parameter without a value prompts for these dates from the keyboard; EOF gives exit code 2.

Variant 30. A taxi dispatch center

1. Initial level. Create a standalone JavaFX application “Taxi dispatch”: drivers, orders, statuses, and bindings. Separate the model and the controller, and implement a list of the main entities and an add form with JavaFX properties. The user enters the specified fields and sees a new row or an error; keep the data in memory and block an invalid action with a binding. Fields: rideId, driverId, addresses, status NEW/ASSIGNED/DONE; a driver cannot have two active rides; assignment and a report of completed rides.

2. Basic level. Create a standalone JavaFX/MVC application “Taxi dispatch” with PostgreSQL: drivers, orders, statuses, and bindings. Implement an FXML list, an edit form, search through a FilteredList, and TableView sorting. Pass the DAO through the constructor or a controller factory; Run JDBC in a Task. After success, refresh the list; after an error, keep the draft; test Cancel, an unknown id, and a restart. Fields: rideId, driverId, addresses, status NEW/ASSIGNED/DONE; a driver cannot have two active rides; assignment and a report of completed rides.

3. Advanced level. Create a standalone JavaFX/MVC application “Taxi dispatch” on PostgreSQL: drivers, orders, statuses, and bindings. Separate a DAO interface, a transaction service, FXML controllers, and a property model; implement CRUD, a domain report, Task/Service, a busy state, and protection against repeated clicks. Add --config=path, --report=from:to, and --help for a report without the GUI: an aligned table and totals, errors to stderr, exit codes 0/2/1. Write service tests with a fake and JDBC tests of rollback and keys, and test cancellation and closing of resources; prepare a jpackage artifact and describe the configuration path. Fields: rideId, driverId, addresses, status NEW/ASSIGNED/DONE; a driver cannot have two active rides; assignment and a report of completed rides. The report filters the main records by an added createdOn field (ISO creation date), both bounds inclusive, with from no later than to. The --report parameter without a value prompts for these dates from the keyboard; EOF gives exit code 2.

Procedure

1. Describe the model, the Save/Cancel scenarios, and the transaction boundaries.
2. Implement and test the service without launching JavaFX.
3. Build the FXML and bindings, and verify that they actually load.
4. Run JDBC in a Task with independent copies of the parameters.
5. Test empty input, a double click, an unknown id, a database failure, cancellation, and reopening the application.
6. Submit the database schema, code, tests, configuration instructions, and genuine screenshots of synthetic data without secrets.