1use crate::resources::FlavorMinimal;
2use crate::user::ProjectMinimal;
3use serde::{Deserialize, Serialize};
4use sqlx::{mysql::MySqlRow, FromRow, Row};
5use std::fmt::Display;
6use tabled::Tabled;
7
8#[derive(Clone, Debug, Deserialize, Serialize, Tabled, PartialEq)]
9pub struct FlavorGroup {
10 pub id: u32,
11 pub name: String,
12 #[tabled(skip)]
13 pub flavors: Vec<u32>,
14 pub project: u32,
15}
16
17impl<'r> FromRow<'r, MySqlRow> for FlavorGroup {
18 fn from_row(row: &'r MySqlRow) -> Result<Self, sqlx::Error> {
19 Ok(Self {
20 id: row.try_get("id")?,
21 name: row.try_get("name")?,
22 flavors: {
23 let flavors: String = row.try_get("flavors")?;
24 flavors.split(',').map(|f| f.parse().unwrap()).collect()
26 },
27 project: row.try_get("project_id")?,
28 })
29 }
30}
31
32impl Display for FlavorGroup {
33 fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
34 f.write_str(&format!("FlavorGroup(id={}, name={})", self.id, self.name))
35 }
36}
37
38#[derive(Clone, Debug, Deserialize, Serialize, Tabled, FromRow, PartialEq)]
39pub struct FlavorGroupMinimal {
40 pub id: u32,
41 pub name: String,
42}
43
44impl Display for FlavorGroupMinimal {
46 fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
47 f.write_str(&format!("FlavorGroup(id={}, name={})", self.id, self.name))
48 }
49}
50
51#[derive(Clone, Debug, Deserialize, Serialize, Tabled, PartialEq)]
52pub struct FlavorGroupDetailed {
53 pub id: u32,
54 pub name: String,
55 #[tabled(skip)]
56 pub flavors: Vec<FlavorMinimal>,
57 pub project: ProjectMinimal,
58}
59
60impl Display for FlavorGroupDetailed {
61 fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
62 f.write_str(&format!("FlavorGroup(id={}, name={})", self.id, self.name))
63 }
64}
65
66#[derive(Clone, Debug, Serialize, Deserialize)]
67pub struct FlavorGroupListParams {
68 pub all: Option<bool>,
69}
70
71#[derive(Clone, Debug, Deserialize, Serialize, Tabled)]
72pub struct FlavorGroupCreated {
73 pub id: u32,
74 pub name: String,
75 #[tabled(skip)]
76 pub flavors: Vec<FlavorMinimal>,
77 pub project: u32,
78}
79
80impl Display for FlavorGroupCreated {
81 fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
82 f.write_str(&format!("FlavorGroup(id={}, name={})", self.id, self.name))
83 }
84}
85
86#[derive(Clone, Debug, Deserialize, Serialize, Tabled)]
87pub struct FlavorGroupInitialize {
88 pub new_flavor_group_count: u32,
89 pub new_flavor_count: u32,
90}
91
92#[derive(Clone, Debug, Serialize, Deserialize)]
93pub struct FlavorGroupCreateData {
94 pub name: String,
95 pub flavors: Vec<u32>,
96}
97
98impl FlavorGroupCreateData {
99 pub fn new(name: String) -> Self {
100 Self {
101 name,
102 flavors: vec![],
103 }
104 }
105}
106
107#[derive(Clone, Debug, Serialize, Deserialize)]
108pub struct FlavorGroupModifyData {
109 pub id: u32,
110
111 #[serde(skip_serializing_if = "Option::is_none")]
112 pub name: Option<String>,
113 #[serde(skip_serializing_if = "Option::is_none")]
114 pub project: Option<u32>,
115}
116
117impl FlavorGroupModifyData {
118 pub fn new(id: u32) -> Self {
119 Self {
120 id,
121 name: None,
122 project: None,
123 }
124 }
125}
126
127#[derive(Clone, Debug, Deserialize, Serialize, Tabled)]
128pub struct FlavorGroupUsage {
129 pub user_id: u32,
130 pub user_name: String,
131 pub flavorgroup_id: u32,
132 pub flavorgroup_name: String,
133 pub usage: u32,
134}
135
136#[derive(Clone, Debug, Deserialize, Serialize, Tabled)]
137pub struct FlavorGroupUsageAggregate {
138 pub flavorgroup_id: u32,
139 pub flavorgroup_name: String,
140 pub usage: u32,
141}