1use crate::types::EntityId;
4use crate::types::HasId;
5use serde::{Deserialize, Serialize};
6
7#[derive(Debug, Clone, PartialEq, Eq, Default, Serialize, Deserialize)]
8pub struct Root {
9 pub id: EntityId,
10 #[serde(with = "chrono::serde::ts_milliseconds")]
11 pub created_at: chrono::DateTime<chrono::Utc>,
12 #[serde(with = "chrono::serde::ts_milliseconds")]
13 pub updated_at: chrono::DateTime<chrono::Utc>,
14 pub workspace: Option<EntityId>,
15 pub system: Option<EntityId>,
16}
17
18impl HasId for Root {
19 fn id(&self) -> EntityId {
20 self.id
21 }
22}
23
24#[derive(Debug, Clone, PartialEq, Eq, Default, Serialize, Deserialize)]
25pub struct Workspace {
26 pub id: EntityId,
27 #[serde(with = "chrono::serde::ts_milliseconds")]
28 pub created_at: chrono::DateTime<chrono::Utc>,
29 #[serde(with = "chrono::serde::ts_milliseconds")]
30 pub updated_at: chrono::DateTime<chrono::Utc>,
31 pub manifest_absolute_path: String,
32 pub global: EntityId,
33 pub entities: Vec<EntityId>,
34 pub features: Vec<EntityId>,
35 pub user_interface: EntityId,
36}
37
38impl HasId for Workspace {
39 fn id(&self) -> EntityId {
40 self.id
41 }
42}
43
44#[derive(Debug, Clone, PartialEq, Eq, Default, Serialize, Deserialize)]
45pub struct System {
46 pub id: EntityId,
47 #[serde(with = "chrono::serde::ts_milliseconds")]
48 pub created_at: chrono::DateTime<chrono::Utc>,
49 #[serde(with = "chrono::serde::ts_milliseconds")]
50 pub updated_at: chrono::DateTime<chrono::Utc>,
51 pub version: String,
52 pub files: Vec<EntityId>,
53}
54
55impl HasId for System {
56 fn id(&self) -> EntityId {
57 self.id
58 }
59}
60
61#[derive(Debug, Clone, PartialEq, Eq, Default, Serialize, Deserialize)]
62pub struct Entity {
63 pub id: EntityId,
64 #[serde(with = "chrono::serde::ts_milliseconds")]
65 pub created_at: chrono::DateTime<chrono::Utc>,
66 #[serde(with = "chrono::serde::ts_milliseconds")]
67 pub updated_at: chrono::DateTime<chrono::Utc>,
68 pub name: String,
69 pub inherits_from: Option<EntityId>,
70 pub only_for_heritage: bool,
71 pub fields: Vec<EntityId>,
72 pub relationships: Vec<EntityId>,
73 pub single_model: bool,
74 pub undoable: bool,
75}
76
77impl HasId for Entity {
78 fn id(&self) -> EntityId {
79 self.id
80 }
81}
82
83#[derive(Debug, Clone, PartialEq, Eq, Default, Serialize, Deserialize)]
84pub struct Field {
85 pub id: EntityId,
86 #[serde(with = "chrono::serde::ts_milliseconds")]
87 pub created_at: chrono::DateTime<chrono::Utc>,
88 #[serde(with = "chrono::serde::ts_milliseconds")]
89 pub updated_at: chrono::DateTime<chrono::Utc>,
90 pub name: String,
91 pub field_type: FieldType,
92 pub entity: Option<EntityId>,
93 pub relationship: FieldRelationshipType,
94 pub optional: bool,
95 pub is_list: bool,
96 pub strong: bool,
97 pub list_model: bool,
98 pub list_model_displayed_field: Option<String>,
99 pub enum_name: Option<String>,
100 pub enum_values: Vec<String>,
101}
102
103impl HasId for Field {
104 fn id(&self) -> EntityId {
105 self.id
106 }
107}
108#[derive(Serialize, Deserialize, Default, Clone, Debug, PartialEq, Eq)]
109pub enum FieldType {
110 #[default]
111 Boolean,
112 Integer,
113 UInteger,
114 Float,
115 String,
116 Uuid,
117 DateTime,
118 Entity,
119 Enum,
120}
121#[derive(Serialize, Deserialize, Default, Clone, Debug, PartialEq, Eq)]
122pub enum FieldRelationshipType {
123 #[default]
124 OneToOne,
125 ManyToOne,
126 OrderedOneToMany,
127 OneToMany,
128 ManyToMany,
129}
130
131#[derive(Debug, Clone, PartialEq, Eq, Default, Serialize, Deserialize)]
132pub struct Feature {
133 pub id: EntityId,
134 #[serde(with = "chrono::serde::ts_milliseconds")]
135 pub created_at: chrono::DateTime<chrono::Utc>,
136 #[serde(with = "chrono::serde::ts_milliseconds")]
137 pub updated_at: chrono::DateTime<chrono::Utc>,
138 pub name: String,
139 pub use_cases: Vec<EntityId>,
140}
141
142impl HasId for Feature {
143 fn id(&self) -> EntityId {
144 self.id
145 }
146}
147
148#[derive(Debug, Clone, PartialEq, Eq, Default, Serialize, Deserialize)]
149pub struct File {
150 pub id: EntityId,
151 #[serde(with = "chrono::serde::ts_milliseconds")]
152 pub created_at: chrono::DateTime<chrono::Utc>,
153 #[serde(with = "chrono::serde::ts_milliseconds")]
154 pub updated_at: chrono::DateTime<chrono::Utc>,
155 pub name: String,
156 pub relative_path: String,
157 pub group: String,
158 pub template_name: String,
159 pub generated_code: Option<String>,
160 pub status: FileStatus,
161 pub nature: FileNature,
162 pub feature: Option<EntityId>,
163 pub all_features: bool,
164 pub entity: Option<EntityId>,
165 pub all_entities: bool,
166 pub use_case: Option<EntityId>,
167 pub all_use_cases: bool,
168 pub field: Option<EntityId>,
169}
170
171impl HasId for File {
172 fn id(&self) -> EntityId {
173 self.id
174 }
175}
176#[derive(Serialize, Deserialize, Default, Clone, Debug, PartialEq, Eq)]
177pub enum FileStatus {
178 #[default]
179 Unknown,
180 Unchanged,
181 Modified,
182 New,
183}
184#[derive(Serialize, Deserialize, Default, Clone, Debug, PartialEq, Eq)]
185pub enum FileNature {
186 #[default]
187 Infrastructure,
188 Aggregate,
189 Scaffold,
190}
191
192#[derive(Debug, Clone, PartialEq, Eq, Default, Serialize, Deserialize)]
193pub struct UseCase {
194 pub id: EntityId,
195 #[serde(with = "chrono::serde::ts_milliseconds")]
196 pub created_at: chrono::DateTime<chrono::Utc>,
197 #[serde(with = "chrono::serde::ts_milliseconds")]
198 pub updated_at: chrono::DateTime<chrono::Utc>,
199 pub name: String,
200 pub entities: Vec<EntityId>,
201 pub undoable: bool,
202 pub read_only: bool,
203 pub long_operation: bool,
204 pub dto_in: Option<EntityId>,
205 pub dto_out: Option<EntityId>,
206}
207
208impl HasId for UseCase {
209 fn id(&self) -> EntityId {
210 self.id
211 }
212}
213
214#[derive(Debug, Clone, PartialEq, Eq, Default, Serialize, Deserialize)]
215pub struct Dto {
216 pub id: EntityId,
217 #[serde(with = "chrono::serde::ts_milliseconds")]
218 pub created_at: chrono::DateTime<chrono::Utc>,
219 #[serde(with = "chrono::serde::ts_milliseconds")]
220 pub updated_at: chrono::DateTime<chrono::Utc>,
221 pub name: String,
222 pub fields: Vec<EntityId>,
223}
224
225impl HasId for Dto {
226 fn id(&self) -> EntityId {
227 self.id
228 }
229}
230
231#[derive(Debug, Clone, PartialEq, Eq, Default, Serialize, Deserialize)]
232pub struct DtoField {
233 pub id: EntityId,
234 #[serde(with = "chrono::serde::ts_milliseconds")]
235 pub created_at: chrono::DateTime<chrono::Utc>,
236 #[serde(with = "chrono::serde::ts_milliseconds")]
237 pub updated_at: chrono::DateTime<chrono::Utc>,
238 pub name: String,
239 pub field_type: DtoFieldType,
240 pub optional: bool,
241 pub is_list: bool,
242 pub enum_name: Option<String>,
243 pub enum_values: Vec<String>,
244}
245
246impl HasId for DtoField {
247 fn id(&self) -> EntityId {
248 self.id
249 }
250}
251#[derive(Serialize, Deserialize, Default, Clone, Debug, PartialEq, Eq)]
252pub enum DtoFieldType {
253 #[default]
254 Boolean,
255 Integer,
256 UInteger,
257 Float,
258 String,
259 Uuid,
260 DateTime,
261 Enum,
262}
263
264#[derive(Debug, Clone, PartialEq, Eq, Default, Serialize, Deserialize)]
265pub struct Global {
266 pub id: EntityId,
267 #[serde(with = "chrono::serde::ts_milliseconds")]
268 pub created_at: chrono::DateTime<chrono::Utc>,
269 #[serde(with = "chrono::serde::ts_milliseconds")]
270 pub updated_at: chrono::DateTime<chrono::Utc>,
271 pub language: String,
272 pub application_name: String,
273 pub organisation_name: String,
274 pub organisation_domain: String,
275 pub prefix_path: String,
276}
277
278impl HasId for Global {
279 fn id(&self) -> EntityId {
280 self.id
281 }
282}
283
284#[derive(Debug, Clone, PartialEq, Eq, Default, Serialize, Deserialize)]
285pub struct Relationship {
286 pub id: EntityId,
287 #[serde(with = "chrono::serde::ts_milliseconds")]
288 pub created_at: chrono::DateTime<chrono::Utc>,
289 #[serde(with = "chrono::serde::ts_milliseconds")]
290 pub updated_at: chrono::DateTime<chrono::Utc>,
291 pub left_entity: Option<EntityId>,
292 pub right_entity: Option<EntityId>,
293 pub field_name: String,
294 pub relationship_type: RelationshipType,
295 pub strength: Strength,
296 pub direction: Direction,
297 pub cardinality: Cardinality,
298 pub order: Option<Order>,
299}
300
301impl HasId for Relationship {
302 fn id(&self) -> EntityId {
303 self.id
304 }
305}
306#[derive(Serialize, Deserialize, Default, Clone, Debug, PartialEq, Eq)]
307pub enum RelationshipType {
308 #[default]
309 OneToOne,
310 ManyToOne,
311 OneToMany,
312 OrderedOneToMany,
313 ManyToMany,
314}
315#[derive(Serialize, Deserialize, Default, Clone, Debug, PartialEq, Eq)]
316pub enum Strength {
317 #[default]
318 Weak,
319 Strong,
320}
321#[derive(Serialize, Deserialize, Default, Clone, Debug, PartialEq, Eq)]
322pub enum Direction {
323 #[default]
324 Forward,
325 Backward,
326}
327#[derive(Serialize, Deserialize, Default, Clone, Debug, PartialEq, Eq)]
328pub enum Cardinality {
329 #[default]
330 ZeroOrOne,
331 One,
332 ZeroOrMore,
333 OneOrMore,
334}
335#[derive(Serialize, Deserialize, Default, Clone, Debug, PartialEq, Eq)]
336pub enum Order {
337 #[default]
338 Ordered,
339 Unordered,
340}
341
342#[derive(Debug, Clone, PartialEq, Eq, Default, Serialize, Deserialize)]
343pub struct UserInterface {
344 pub id: EntityId,
345 #[serde(with = "chrono::serde::ts_milliseconds")]
346 pub created_at: chrono::DateTime<chrono::Utc>,
347 #[serde(with = "chrono::serde::ts_milliseconds")]
348 pub updated_at: chrono::DateTime<chrono::Utc>,
349 pub rust_cli: bool,
350 pub rust_slint: bool,
351 pub cpp_qt_qtwidgets: bool,
352 pub cpp_qt_qtquick: bool,
353 pub rust_ios: bool,
354 pub rust_android: bool,
355}
356
357impl HasId for UserInterface {
358 fn id(&self) -> EntityId {
359 self.id
360 }
361}