UltraGoose
/
BreweryControlSystem
1
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity

сегодня защита и оно почти готово

master
Алексей Алексей 2026-06-26 08:35:35 +10:00
parent 09ed906aa7
commit 69525d37d2
6 changed files with 401 additions and 12 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

9
code/src/app.rs
View File

@ -6,6 +6,7 @@ use std::{
};
use crate::{
client_tab::ClientTab,
database::DBOperator,
material_tab::MaterialTabViewer,
misc::{self, ELEMENTS_PER_PAGE},
@ -195,6 +196,7 @@ struct MainTabViewer {
recipe_tab: RecipeTabViewer,
order_tabs: OrderTabViewer,
order_tree: egui_dock::DockState<Tab>,
client_tab: ClientTab,
equipment_modal_state: EquipmentModalState,
salary_modal_state: SalaryModalState,
@ -265,7 +267,7 @@ impl Default for MainTabViewer {
tab_type: TabTypes::Recipe,
},
Tab {
title: "Производство".to_owned(),
title: "Продукция".to_owned(),
tab_type: TabTypes::Product,
},
]),
@ -280,6 +282,7 @@ impl Default for MainTabViewer {
tab_type: TabTypes::OutcomingOrderList,
},
]),
client_tab: ClientTab::default(),
rt,
is_dark_theme: true,
interface_scale_ratio: 1.2,
@ -389,6 +392,7 @@ impl MainTabViewer {
material_tabs: MaterialTabViewer::new(is_admin),
recipe_tab: RecipeTabViewer::new(is_admin),
order_tabs: OrderTabViewer::new(is_admin),
client_tab: ClientTab::new(is_admin),
..Default::default()
}
}
@ -1024,6 +1028,9 @@ impl egui_dock::TabViewer for MainTabViewer {
TabTypes::Order => {
&self.show_order(ui);
}
TabTypes::Client => {
&self.client_tab.show_tab(ui);
}
_ => {
ui.label("Welcome to Avalonia!");
}

204
code/src/client_tab.rs Normal file
View File

@ -0,0 +1,204 @@
use std::sync::Arc;
use bigdecimal::ToPrimitive;
use egui::{Sense, mutex::RwLock};
use egui_extras::Column;
use crate::{
database::DBOperator,
misc,
models::{Client, ClientModalState, ModalStatus},
};
pub struct ClientTab {
db_oper: DBOperator,
rt: tokio::runtime::Runtime,
clients: Arc<RwLock<Vec<Client>>>,
client_page: i32,
is_admin: bool,
process_client_state: ClientModalState,
}
impl ClientTab {
fn update_clients(&mut self) {
self.clients = Arc::new(RwLock::new(self.rt.block_on(async {
self.db_oper
.get_clients(
self.client_page * misc::ELEMENTS_PER_PAGE,
misc::ELEMENTS_PER_PAGE,
)
.await
})));
}
pub fn new(is_admin: bool) -> Self {
Self {
is_admin,
..Default::default()
}
}
pub fn show_tab(&mut self, ui: &mut egui::Ui) {
ui.horizontal(|ui| {
if self.is_admin {
if ui.button("Добавить").clicked() {
self.process_client_state.is_open = true;
self.process_client_state.status = ModalStatus::Add;
self.process_client_state.client = Client::default();
}
}
if ui.button("<-").clicked() {
if self.client_page > 0 {
self.client_page -= 1;
self.update_clients();
}
}
ui.monospace(self.client_page.to_string());
if ui.button("->").clicked() {
if self.clients.read().len().to_i32().unwrap() == misc::ELEMENTS_PER_PAGE {
self.client_page += 1;
self.update_clients();
}
}
});
egui_extras::TableBuilder::new(ui)
.striped(true)
.vscroll(false)
.sense(Sense::click())
.columns(Column::auto(), 3)
.header(25.0, |mut head| {
head.col(|ui| {
ui.heading("Название ");
});
head.col(|ui| {
ui.heading("Адрес");
});
head.col(|ui| {
ui.heading(" ");
});
})
.body(|mut body| {
for cl in self.clients.read().iter() {
body.row(25.0, |mut row| {
row.col(|ui| {
ui.label(cl.name.clone());
});
row.col(|ui| {
ui.label(cl.address.clone());
});
if self.is_admin {
row.col(|ui| {
if ui.button("Удалить").clicked() {
self.process_client_state.is_open = true;
self.process_client_state.client = cl.clone();
self.process_client_state.status = ModalStatus::Remove;
}
});
if row.response().double_clicked() {
self.process_client_state.is_open = true;
self.process_client_state.client = cl.clone();
self.process_client_state.status = ModalStatus::Edit;
}
}
});
}
});
if self.process_client_state.is_open {
egui::Modal::new(egui::Id::new("process_client_modal")).show(ui.ctx(), |ui| {
if ui.button("Закрыть").clicked() {
self.process_client_state.is_open = false;
}
if self.process_client_state.status != ModalStatus::Remove {
egui::Grid::new("process_client_grid").show(ui, |ui| {
let mut size = ui.available_size();
size.x = 80.0;
ui.label("Имя клиента:");
ui.add_sized(
size,
egui::TextEdit::singleline(&mut self.process_client_state.client.name),
);
ui.end_row();
ui.label("Адрес клиента:");
ui.add_sized(
size,
egui::TextEdit::singleline(
&mut self.process_client_state.client.address,
),
);
ui.end_row();
});
} else {
ui.label(format!(
"Удалить {}?",
self.process_client_state.client.name
));
}
let btext = match self.process_client_state.status {
ModalStatus::Add => "Добавить",
ModalStatus::Edit => "Сохранить",
ModalStatus::Remove => "Удалить",
};
self.process_client_state.can_finish = match self.process_client_state.status {
ModalStatus::Remove => true,
_ => {
self.process_client_state.client.name.len() > 0
&& self.process_client_state.client.address.len() > 0
}
};
if ui
.add_enabled(
self.process_client_state.can_finish,
egui::Button::new(btext),
)
.clicked()
{
match self.process_client_state.status {
ModalStatus::Add => {
self.rt.block_on(async {
self.db_oper
.add_client(self.process_client_state.client.clone())
.await
.ok()
});
}
ModalStatus::Edit => {
self.rt.block_on(async {
self.db_oper
.update_client(self.process_client_state.client.clone())
.await
.ok()
});
}
ModalStatus::Remove => {
self.rt.block_on(async {
self.db_oper
.remove_client(self.process_client_state.client.id)
.await
.ok()
});
}
}
self.update_clients();
self.process_client_state.is_open = false;
}
});
}
}
}
impl Default for ClientTab {
fn default() -> Self {
let rt = tokio::runtime::Runtime::new().unwrap();
let db_oper = rt.block_on(async { DBOperator::new().await });
Self {
clients: Arc::new(RwLock::new(rt.block_on(async {
db_oper.get_clients(0, misc::ELEMENTS_PER_PAGE).await
}))),
db_oper,
rt,
is_admin: Default::default(),
client_page: 0,
process_client_state: ClientModalState::default(),
}
}
}

62
code/src/database.rs
View File

@ -789,6 +789,68 @@ impl DBOperator {
None => Err(sqlx::Error::BeginFailed),
}
}
pub async fn get_order_id_by_order_element_id(
&self,
element_id: i32,
) -> Result<i32, sqlx::Error> {
let ret: i32 = sqlx::query_scalar("SELECT order_id FROM order_element WHERE id=?")
.bind(element_id)
.fetch_one(&self.pool)
.await?;
Ok(ret)
}
pub async fn add_order_element(&self, order_elem: OrderElement) -> Result<(), sqlx::Error> {
match sqlx::query("INSERT INTO order_element (order_id, product_id, quantity, total_amount) VALUES(?, ?, ?, ?);")
.bind(self.get_order_id_by_order_element_id(order_elem.id).await.unwrap())
.bind(order_elem.product.id)
.bind(order_elem.quantity)
.bind(order_elem.total_price)
.execute(&self.pool).await{
Ok(_) => Ok(()),
Err(e) => Err(e)
}
}
pub async fn get_clients(&self, start: i32, length: i32) -> Vec<Client> {
let pret = sqlx::query_as::<_, Client>("SELECT * FROM client LIMIT ? OFFSET ?")
.bind(length)
.bind(start)
.fetch_all(&self.pool)
.await;
pret.unwrap()
}
pub async fn add_client(&self, client: Client) -> Result<(), sqlx::Error> {
match sqlx::query("INSERT INTO client (name, address) VALUES(?, ?);")
.bind(client.name)
.bind(client.address)
.execute(&self.pool)
.await
{
Ok(_) => Ok(()),
Err(e) => Err(e),
}
}
pub async fn update_client(&self, client: Client) -> Result<(), sqlx::Error> {
match sqlx::query("UPDATE client SET name=?, address=? WHERE id=?;")
.bind(client.name)
.bind(client.address)
.bind(client.id)
.execute(&self.pool)
.await
{
Ok(_) => Ok(()),
Err(e) => Err(e),
}
}
pub async fn remove_client(&self, client_id: i32) -> Result<(), sqlx::Error> {
match sqlx::query("DELETE FROM client WHERE id=?")
.bind(client_id)
.execute(&self.pool)
.await
{
Ok(_) => Ok(()),
Err(e) => Err(e),
}
}
}
pub async fn estabilish_connection() -> Result<(), sqlx::Error> {

3
code/src/main.rs
View File

@ -1,15 +1,16 @@
#![cfg_attr(not(debug_assertions), windows_subsystem = "windows")]
mod app;
mod client_tab;
mod database;
mod material_tab;
mod misc;
mod models;
mod order_tab;
mod recipe_tab;
mod reports;
mod tab;
mod worker_tab;
mod misc;
fn main() {
dotenvy::dotenv().ok();

9
code/src/models.rs
View File

@ -125,7 +125,7 @@ pub struct RecipeRow {
pub id: i32,
pub name: String,
}
#[derive(FromRow, Default, PartialEq, Eq, PartialOrd, Ord)]
#[derive(FromRow, Default, PartialEq, Eq, PartialOrd, Ord, Clone)]
pub struct Client {
pub id: i32,
pub name: String,
@ -270,6 +270,13 @@ pub struct OrderModalState {
pub order: Order,
pub status: ModalStatus,
}
#[derive(Default)]
pub struct ClientModalState {
pub is_open: bool,
pub can_finish: bool,
pub client: Client,
pub status: ModalStatus,
}
#[derive(Default, PartialEq)]
pub enum ModalStatus {

120
code/src/order_tab.rs
View File

@ -7,7 +7,9 @@ use egui_extras::Column;
use crate::{
database::DBOperator,
misc,
models::{ModalStatus, Order, OrderElement, OrderElementModalState, OrderModalState},
models::{
Client, ModalStatus, Order, OrderElement, OrderElementModalState, OrderModalState, Product,
},
tab::{TABS_CAN_BE_WINDOWS, Tab, TabTypes},
};
@ -17,12 +19,16 @@ pub struct OrderTabViewer {
incoming_orders: Arc<RwLock<Vec<Order>>>,
outcoming_orders: Arc<RwLock<Vec<Order>>>,
products: Arc<RwLock<Vec<Product>>>,
clients: Arc<RwLock<Vec<Client>>>,
incoming_order_page: i32,
outcoming_order_page: i32,
products_page: i32,
is_admin: bool,
process_order_state: OrderModalState,
process_element_state: OrderElementModalState,
client_page: i32,
}
impl OrderTabViewer {
@ -54,6 +60,16 @@ impl OrderTabViewer {
));
});
}
fn update_clients(&mut self) {
self.clients = Arc::new(RwLock::new(self.rt.block_on(async {
self.db_oper
.get_clients(
self.client_page * misc::ELEMENTS_PER_PAGE,
misc::ELEMENTS_PER_PAGE,
)
.await
})));
}
fn show_order_element_modal(&mut self, ui: &mut egui::Ui) {
egui::Modal::new(egui::Id::new("order_element_modal")).show(ui.ctx(), |ui| {
if ui.button("Закрыть").clicked() {
@ -61,7 +77,44 @@ impl OrderTabViewer {
}
egui::Grid::new("order_element_grid").show(ui, |ui| {
ui.label("Продукт:");
///
egui::ComboBox::new("process_element_combobox", "")
.selected_text(
self.process_element_state
.element
.product
.recipe
.name
.clone(),
)
.show_ui(ui, |ui| {
ui.horizontal(|ui| {
if ui.button("<-").clicked() {
if self.products_page > 0 {
self.products_page -= 1;
self.update_products();
}
}
ui.monospace(self.products_page.to_string());
if ui.button("->").clicked() {
if self.products.read().len().to_i32().unwrap()
== misc::ELEMENTS_PER_PAGE
{
self.products_page += 1;
self.update_products();
}
}
});
for prod in self.products.read().clone() {
ui.selectable_value(
&mut self.process_element_state.element.product,
prod.clone(),
format!(
"{} {} ед. | {}/шт.",
prod.recipe.name, prod.volume, prod.price_per_unit
),
);
}
});
ui.end_row();
ui.label("Количество:");
@ -80,7 +133,39 @@ impl OrderTabViewer {
.price_per_unit
.clone()
* self.process_element_state.element.quantity
))
));
ui.end_row();
let btext = match self.process_element_state.status {
ModalStatus::Add => "Добавить",
_ => "Подтвердить",
};
self.process_element_state.can_finish = match self.process_element_state.status {
ModalStatus::Add => {
self.process_element_state.element.product.id != 0
&& self.process_element_state.element.quantity > 0
}
_ => true,
};
if ui
.add_enabled(
self.process_element_state.can_finish,
egui::Button::new(btext),
)
.clicked()
{
self.process_element_state.element.total_price = self
.process_element_state
.element
.product
.price_per_unit
.clone()
* self.process_element_state.element.quantity;
self.process_order_state
.order
.elements
.insert(self.process_element_state.element.clone());
self.process_element_state.is_open = false;
}
});
});
}
@ -100,12 +185,12 @@ impl OrderTabViewer {
if ui.button("<-").clicked() {
if incoming_orders {
if self.incoming_orders.read().len() > 0 {
if self.incoming_order_page > 0 {
self.incoming_order_page -= 1;
self.update_orders();
}
} else {
if self.outcoming_orders.read().len() > 0 {
if self.outcoming_order_page > 0 {
self.outcoming_order_page -= 1;
self.update_orders();
}
@ -185,16 +270,20 @@ impl OrderTabViewer {
self.process_order_state.is_open = false
}
egui::Grid::new("order_process_grid").show(ui, |ui| {
if self.process_order_state.status != ModalStatus::Add {
ui.label("ID заказа:");
ui.label(self.process_order_state.order.id.to_string());
ui.end_row();
}
ui.label(if incoming_orders {
"Заказчик"
} else {
"Клиент"
});
//ВЫБОР КЛИЕНТА
egui::ComboBox::new("select_client_combobox", "")
.selected_text(&self.process_order_state.order.client.name)
.show_ui(ui, |ui| {});
ui.end_row();
ui.label("Элементы");
@ -232,6 +321,17 @@ impl OrderTabViewer {
self.show_order_element_modal(ui);
}
}
fn update_products(&mut self) {
self.products = Arc::new(RwLock::new(self.rt.block_on(async {
self.db_oper
.get_products(
self.products_page * misc::ELEMENTS_PER_PAGE,
misc::ELEMENTS_PER_PAGE,
)
.await
})));
}
}
impl egui_dock::TabViewer for OrderTabViewer {
@ -273,9 +373,17 @@ impl Default for OrderTabViewer {
outcoming_orders: Arc::new(RwLock::new(
rt.block_on(async { db_oper.get_orders(0, misc::ELEMENTS_PER_PAGE, false).await }),
)),
products: Arc::new(RwLock::new(rt.block_on(async {
db_oper.get_products(0, misc::ELEMENTS_PER_PAGE).await
}))),
clients: Arc::new(RwLock::new(rt.block_on(async {
db_oper.get_clients(0, misc::ELEMENTS_PER_PAGE).await
}))),
incoming_order_page: 0,
outcoming_order_page: 0,
products_page: 0,
client_page: 0,
db_oper,
rt,
is_admin: false,