Start with the problem.
Name the actors, records, decisions, or messages. Use an AI Automation template to turn your brief into PlantUML, or bring your own source.
Black Friday Special — $25 USD. Create editable PlantUML diagrams from natural-language descriptions inside Odoo. Generate class, sequence, and entity relationship diagrams, render images, and share selected diagrams.
Original Odoo 18 source with the AI Automation dependency. Configure your own AI credentials and Java/PlantUML setup; third-party usage charges may apply.
AI Enterprise Architect / Odoo 18
A data model. A difficult integration. A workflow that nobody can quite explain.
Describe what needs to happen. Turn that description into PlantUML, review the diagram, and refine the source until the relationships are clear.
Keep the explanation next to the work, inside Odoo.
Explore the worked examples ↓From a brief to a shared understanding
Name the actors, records, decisions, or messages. Use an AI Automation template to turn your brief into PlantUML, or bring your own source.
Inspect the relationships and the assumptions. Edit the PlantUML and render again. AI gives you a starting point; you decide whether the model is right.
Use the rendered image in a discussion or enable a sharing link for a selected diagram. A useful diagram makes the next decision easier.
The worked-example collection
Compare the same three worlds through structure, behavior, and architecture. Choose a diagram type to see its Monopoly, Risk, and Air Traffic Control examples.
Open a diagram at full size, inspect its source, or download the PlantUML file as a starting point. These are hand-authored teaching examples rendered with PlantUML; they are not claims about AI output quality. Game models simplify the rules. Aviation examples are fictional teaching models, not operational guidance.
Monopoly
A player can own many properties; each property has at most one owner.
@startuml
class Player {
cash : Decimal
}
class Property {
purchasePrice : Decimal
rent : Decimal
}
Player "0..1" -- "0..*" Property : owns
@enduml
Risk
Every territory has one owner in this simplified mid-game model.
@startuml
class Player
class Territory {
armyCount : Integer
}
class Continent
Player "1" -- "1..*" Territory : controls
Continent "1" *-- "1..*" Territory : contains
Territory "0..*" -- "0..*" Territory : borders
@enduml
Air Traffic Control
A clearance belongs to one flight; a flight accumulates a clearance history.
@startuml
class Flight {
callsign : String
}
class Clearance {
issuedAt : DateTime
instruction : String
}
class Controller
Flight "1" -- "0..*" Clearance : receives
Controller "1" -- "0..*" Clearance : issues
@enduml
Monopoly
A snapshot gives instance names and values, rather than just class names.
@startuml
object "alex : Player" as alex {
cash = 1200
}
object "boardwalk : Property" as boardwalk {
purchasePrice = 400
}
alex -- boardwalk : owns
@enduml
Risk
One player controls two territories, each with a different army count.
@startuml
object "red : Player" as red
object "alaska : Territory" as alaska {
armies = 5
}
object "alberta : Territory" as alberta {
armies = 3
}
red -- alaska : controls
red -- alberta : controls
alaska -- alberta : borders
@enduml
Air Traffic Control
Illustrative identifiers connect a flight, a controller, and a clearance.
@startuml
object "flight72 : Flight" as flight {
callsign = DEMO72
}
object "tower1 : Controller" as tower
object "clearance8 : Clearance" as clearance {
instruction = Hold position
}
tower -- clearance : issues
clearance -- flight : applies to
@enduml
Monopoly
The game checks ownership and the rent rule before moving money.
@startuml
actor Player
participant "Game rules" as Rules
participant "Bank ledger" as Bank
Player -> Rules : Land on owned property
Rules -> Rules : Check owner and rent
Rules -> Bank : Transfer rent to owner
Bank --> Rules : Transfer recorded
Rules --> Player : Show updated balance
@enduml
Risk
The server validates the proposed move before resolving the dice.
@startuml
actor Attacker
participant "Game server" as Game
participant "Dice service" as Dice
Attacker -> Game : Attack adjacent territory
Game -> Game : Validate ownership and armies
Game -> Dice : Roll attack and defence
Dice --> Game : Dice results
Game -> Game : Apply losses
Game --> Attacker : Updated territory state
@enduml
Air Traffic Control
The flight crew reads back the instruction; the controller checks that readback.
@startuml
actor "Flight crew" as Crew
participant Controller
participant "Clearance log" as Log
Crew -> Controller : Request taxi clearance
Controller -> Log : Record instruction
Controller --> Crew : Issue taxi clearance
Crew -> Controller : Read back instruction
Controller -> Controller : Check readback
Controller --> Crew : Confirm or correct
@enduml
Monopoly
Buying and auctioning are different paths after landing on an unowned property.
@startuml
start
:Land on unowned property;
if (Player chooses to buy?) then (yes)
:Pay purchase price;
:Record ownership;
else (no)
:Offer property at auction;
endif
:Continue turn;
stop
@enduml
Risk
The process distinguishes legal moves from a refused request.
@startuml
start
:Select source and target;
if (Adjacent and enough armies?) then (yes)
:Choose legal dice counts;
:Roll dice and apply losses;
else (no)
:Explain invalid attack;
endif
stop
@enduml
Air Traffic Control
This simplified process shows a holding path without implying a real separation algorithm.
@startuml
start
:Receive departure request;
:Review runway and traffic information;
if (Departure conditions satisfied?) then (yes)
:Issue departure clearance;
:Check crew readback;
else (no)
:Instruct crew to hold;
endif
:Record outcome;
stop
@enduml
Monopoly
Buying changes an unowned property to owned; mortgage status is explicit.
@startuml
[*] --> Unowned
Unowned --> Owned : purchase
Owned --> Mortgaged : mortgage [no buildings]
Mortgaged --> Owned : redeem
Owned --> Unowned : return to bank
Mortgaged --> Unowned : return to bank
@enduml
Risk
An individual turn moves through reinforcement, attack, and fortification.
@startuml
[*] --> Reinforce
Reinforce --> Attack : reinforcements placed
Attack --> Attack : another legal attack
Attack --> Fortify : end attacks
Fortify --> Complete : fortify or skip
Complete --> [*]
@enduml
Air Traffic Control
A clearance record can be acknowledged, replaced, or cancelled.
@startuml
[*] --> Draft
Draft --> Issued : controller issues
Issued --> Acknowledged : correct readback
Issued --> Cancelled : cancel
Acknowledged --> Superseded : replacement issued
Acknowledged --> Completed : instruction completed
Cancelled --> [*]
Superseded --> [*]
Completed --> [*]
@enduml
Monopoly
The rectangle is the application boundary; the ovals are goals, not a click sequence.
@startuml
left to right direction
actor Player
rectangle "Monopoly game" {
usecase "Take a turn" as Turn
usecase "Buy a property" as Buy
usecase "Propose a trade" as Trade
}
Player -- Turn
Player -- Buy
Player -- Trade
@enduml
Risk
Players interact with a shared game through distinct goals.
@startuml
left to right direction
actor Player
rectangle "Risk game" {
usecase "Place reinforcements" as Place
usecase "Attack a territory" as Attack
usecase "Fortify a territory" as Fortify
}
Player -- Place
Player -- Attack
Player -- Fortify
@enduml
Air Traffic Control
Actors participate in system goals; this does not define authorization policy.
@startuml
left to right direction
actor Controller
actor "Flight crew" as Crew
rectangle "Clearance support system" {
usecase "Review flight information" as Review
usecase "Issue a clearance" as Issue
usecase "Acknowledge instruction" as Ack
}
Controller -- Review
Controller -- Issue
Crew -- Ack
@enduml
Monopoly
The rules component owns game decisions; the ledger records money movements.
@startuml
[Player interface] --> [Turn rules] : commands
[Turn rules] --> [Property register] : ownership
[Turn rules] --> [Bank ledger] : transfers
[Property register] --> [Game persistence]
[Bank ledger] --> [Game persistence]
@enduml
Risk
Map, combat, and turn logic have separate responsibilities.
@startuml
[Game client] --> [Turn coordinator]
[Turn coordinator] --> [Map rules]
[Turn coordinator] --> [Combat resolver]
[Combat resolver] --> [Dice source]
[Turn coordinator] --> [Game repository]
@enduml
Air Traffic Control
This is a teaching decomposition, not a certified ATC architecture.
@startuml
[Controller display] --> [Clearance service]
[Clearance service] --> [Flight information]
[Clearance service] --> [Clearance log]
[Clearance service] --> [Communication adapter]
@enduml
Monopoly
Deployment shows runtime locations rather than business concepts.
@startuml
node "Player device" {
artifact "Browser client" as Client
}
node "Application host" {
artifact "Game service" as Game
}
node "Database host" {
database "Game database" as DB
}
Client --> Game : HTTPS
Game --> DB : SQL
@enduml
Risk
Two clients connect to one authoritative match service.
@startuml
node "Player A device" as A
node "Player B device" as B
node "Match host" {
artifact "Match service" as Match
}
database "Match database" as DB
A --> Match : HTTPS
B --> Match : HTTPS
Match --> DB : persist state
@enduml
Air Traffic Control
A deliberately fictional training deployment keeps examples separate from live aviation systems.
@startuml
node "Training workstation" {
artifact "Controller UI" as UI
}
node "Simulator host" {
artifact "Scenario service" as Sim
}
node "Training data host" {
database "Scenario records" as DB
}
UI --> Sim : training commands
Sim --> DB : save exercise
@enduml
Monopoly
Dependencies point from a consumer package to the package it uses.
@startuml
package "Game domain" as Domain {
class Turn
class Property
}
package "Presentation" as UI {
class GameScreen
}
package "Persistence" as Storage {
class GameRepository
}
UI ..> Domain
Storage ..> Domain
@enduml
Risk
Combat and turn orchestration depend on the map model.
@startuml
package "Turn management" as Turns
package "Combat" as Combat
package "Map model" as Map
Turns ..> Combat
Turns ..> Map
Combat ..> Map
@enduml
Air Traffic Control
The controller interface consumes clearance and flight-information packages.
@startuml
package "Controller interface" as UI
package "Clearance domain" as Clearances
package "Flight information" as Flights
package "Audit adapters" as Audit
UI ..> Clearances
Clearances ..> Flights
Audit ..> Clearances
@enduml
Monopoly
Illustrative game ticks show when each turn phase is active.
@startuml
robust "Turn phase" as Phase
@0
Phase is Roll
@2
Phase is Resolve
@5
Phase is Complete
@enduml
Risk
One shared time axis makes the handoff between game phases explicit.
@startuml
robust "Game phase" as Phase
@0
Phase is Reinforce
@3
Phase is Attack
@8
Phase is Fortify
@10
Phase is Complete
@enduml
Air Traffic Control
These are illustrative ticks, not aviation timing requirements or safety limits.
@startuml
robust "Clearance" as Clearance
@0
Clearance is Requested
@2
Clearance is Issued
@4
Clearance is Acknowledged
@8
Clearance is Completed
@enduml
Monopoly
Ownership is optional for a property; a game contains many property records.
@startuml
entity Game {
* id : integer <<PK>>
}
entity Player {
* id : integer <<PK>>
--
game_id : integer <<FK>>
}
entity Property {
* id : integer <<PK>>
--
game_id : integer <<FK>>
owner_id : integer <<FK, nullable>>
}
Game ||--|{ Player : has
Game ||--|{ Property : contains
Player |o--o{ Property : owns
@enduml
Risk
A territory position belongs to one match and references one map territory.
@startuml
entity Match {
* id : integer <<PK>>
}
entity Territory {
* id : integer <<PK>>
--
name : text
}
entity TerritoryPosition {
* id : integer <<PK>>
--
match_id : integer <<FK>>
territory_id : integer <<FK>>
army_count : integer
}
Match ||--|{ TerritoryPosition : contains
Territory ||--o{ TerritoryPosition : appears_in
@enduml
Air Traffic Control
Each clearance references a flight and its issuing controller.
@startuml
entity Flight {
* id : integer <<PK>>
--
callsign : text
}
entity Controller {
* id : integer <<PK>>
}
entity Clearance {
* id : integer <<PK>>
--
flight_id : integer <<FK>>
controller_id : integer <<FK>>
issued_at : timestamp
}
Flight ||--o{ Clearance : receives
Controller ||--o{ Clearance : issues
@enduml
See the workflow
Watch the product demonstration to see the diagramming workflow inside Odoo. Then use the examples above to explore the notation at your own pace.
The recording demonstrates the workflow; the exact interface can vary with your installed version.
Know what you are buying
Original Odoo 18 application source, with the AI Automation dependency included.
A few practical questions
This product is application source for your Odoo environment. Hosting, installation, AI provider usage, and ongoing operational services are not bundled into this purchase.
You can work directly with PlantUML source. AI-assisted generation additionally requires configured AI Automation templates and your own provider credentials.
Yes. Each example includes a downloadable PlantUML file. You can adapt the names, relationships, and rules to your own project and render the result with a compatible PlantUML setup.
Sharing is enabled for a selected diagram. Treat an enabled sharing URL as an access link: anyone holding it may be able to view that shared diagram.
No. Check the syntax, the business rules, and the relationships. A rendered image confirms that the source can be drawn; it does not prove that your design is correct.
Build a clearer picture
Explore the examples, watch the demo, or return to the purchase options.
We may limit participation to 25 active subscriptions. Participation with Greg Moss specifically is subject to his availability.