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

Compare commits

base: UltraGoose:09ed906aa73e03875fa5e8547fb7f63f30e3d246
Branches Tags
UltraGoose:master
...
compare: UltraGoose:a1cc8e4e86e26f46ee8e39fcc5139908d11598f3
Branches Tags
UltraGoose:master

2 Commits
09ed906aa7 ... a1cc8e4e86

Author SHA1 Message Date
Алексей Алексей a1cc8e4e86 помогите 2026-06-26 10:42:57 +10:00
Алексей Алексей 69525d37d2 сегодня защита и оно почти готово 2026-06-26 08:35:35 +10:00
10 changed files with 862 additions and 162 deletions
Show Stats Expand all files Collapse all files

98
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()
}
}
@ -660,31 +664,42 @@ impl MainTabViewer {
.show_inside(ui, &mut self.order_tabs);
}
fn show_salary(&mut self, ui: &mut egui::Ui) {
/*
* Чё надо:
* 1. Список платежей.
*/
if self.is_admin && ui.button("Добавить").clicked() {
self.salary_modal_state
.data
.insert("id".to_owned(), String::new());
self.salary_modal_state
.data
.insert("worker_id".to_owned(), String::new());
self.salary_modal_state
.data
.insert("salary_size".to_owned(), String::new());
self.salary_modal_state
.data
.insert("salary_date".to_owned(), String::new());
self.salary_modal_state
.data
.insert("comment".to_owned(), String::new());
self.salary_modal_state.workers.clear();
self.salary_modal_state.is_open = true;
self.salary_modal_state.status = ModalStatus::Add;
}
ui.horizontal(|ui| {
if self.is_admin && ui.button("Добавить").clicked() {
self.update_workers();
self.salary_modal_state
.data
.insert("id".to_owned(), String::new());
self.salary_modal_state
.data
.insert("worker_id".to_owned(), String::new());
self.salary_modal_state
.data
.insert("salary_size".to_owned(), String::new());
self.salary_modal_state
.data
.insert("salary_date".to_owned(), String::new());
self.salary_modal_state
.data
.insert("comment".to_owned(), String::new());
self.salary_modal_state.workers.clear();
self.salary_modal_state.is_open = true;
self.salary_modal_state.status = ModalStatus::Add;
}
if ui.button("<-").clicked() {
if self.salaries_page > 0 {
self.salaries_page -= 1;
self.update_salary();
}
}
ui.monospace(self.salaries_page.to_string());
if ui.button("->").clicked() {
if self.salaries.read().len().to_i32().unwrap() == misc::ELEMENTS_PER_PAGE {
self.salaries_page += 1;
self.update_salary();
}
}
});
TableBuilder::new(ui)
.striped(true)
.columns(Column::auto(), 5)
@ -791,19 +806,21 @@ impl MainTabViewer {
.close_behavior(egui::PopupCloseBehavior::CloseOnClickOutside)
.show_ui(ui, |ui| {
for wrkr in self.workers.read().clone().iter() {
let mut checked =
self.salary_modal_state.workers.contains(wrkr);
let res = ui.add(egui::Checkbox::new(
&mut checked,
&wrkr.full_name,
));
if res.clicked() {
if checked {
self.salary_modal_state
.workers
.insert(wrkr.clone());
} else {
self.salary_modal_state.workers.remove(wrkr);
if !wrkr.is_fired {
let mut checked =
self.salary_modal_state.workers.contains(wrkr);
let res = ui.add(egui::Checkbox::new(
&mut checked,
&wrkr.full_name,
));
if res.clicked() {
if checked {
self.salary_modal_state
.workers
.insert(wrkr.clone());
} else {
self.salary_modal_state.workers.remove(wrkr);
}
}
}
}
@ -1024,6 +1041,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(),
}
}
}

179
code/src/database.rs
View File

@ -1,4 +1,5 @@
use bigdecimal::BigDecimal;
use bigdecimal::ToPrimitive;
use chrono::DateTime;
use sqlx::Row;
use sqlx::mysql::MySqlPool;
@ -24,10 +25,17 @@ impl DBOperator {
pool: MySqlPool::connect(&db_url).await.unwrap(),
}
}
pub async fn get_position(&self) -> Result<Vec<Position>, sqlx::Error> {
let rets: Vec<Position> = sqlx::query_as::<_, Position>("SELECT * FROM `position`")
.fetch_all(&self.pool)
.await?;
pub async fn get_positions(
&self,
start: i32,
length: i32,
) -> Result<Vec<Position>, sqlx::Error> {
let rets: Vec<Position> =
sqlx::query_as::<_, Position>("SELECT * FROM `position` LIMIT ? OFFSET ?")
.bind(length)
.bind(start)
.fetch_all(&self.pool)
.await?;
Ok(rets)
}
pub async fn get_position_by_id(&self, id: i32) -> Result<Position, sqlx::Error> {
@ -53,15 +61,11 @@ impl DBOperator {
.fetch_all(&self.pool)
.await?;
let mut rets: Vec<Worker> = Vec::new();
let pos = self.get_position().await.unwrap();
for worker in pre_rets {
let mut ppos = Position::default();
for position in pos.clone() {
if position.id == worker.position_id {
ppos = position.clone();
break;
}
}
let ppos = self
.get_position_by_id(worker.position_id)
.await
.unwrap_or(Position::default());
rets.push(Worker {
id: worker.id,
full_name: worker.full_name,
@ -187,8 +191,14 @@ impl DBOperator {
.await?;
Ok(rets)
}
pub async fn get_materials(&self) -> Result<Vec<Material>, sqlx::Error> {
let mats = sqlx::query_as::<_, MaterialRow>("SELECT * FROM `material`")
pub async fn get_materials(
&self,
start: i32,
length: i32,
) -> Result<Vec<Material>, sqlx::Error> {
let mats = sqlx::query_as::<_, MaterialRow>("SELECT * FROM `material` LIMIT ? OFFSET ?")
.bind(length)
.bind(start)
.fetch_all(&self.pool)
.await?;
let cats = self.get_mcat().await?;
@ -346,13 +356,16 @@ impl DBOperator {
}
pub async fn update_worker(&self, worker: Worker) -> Result<bool, sqlx::Error> {
match sqlx::query("UPDATE `worker` SET hire_date=?, is_fired=?, full_name=? WHERE id=?;")
.bind(worker.hire_date)
.bind(worker.is_fired)
.bind(worker.full_name)
.bind(worker.id)
.execute(&self.pool)
.await
match sqlx::query(
"UPDATE `worker` SET hire_date=?, is_fired=?, full_name=?, fire_date=? WHERE id=?;",
)
.bind(worker.hire_date)
.bind(worker.is_fired)
.bind(worker.full_name)
.bind(worker.fire_date)
.bind(worker.id)
.execute(&self.pool)
.await
{
Ok(_) => Ok(true),
Err(_) => Ok(false),
@ -587,6 +600,24 @@ impl DBOperator {
Err(_) => Ok(false),
}
}
pub async fn get_mat_by_id(&self, mat_id: i32) -> Result<Material, sqlx::Error> {
let pret = sqlx::query_as::<_, MaterialRow>("SELECT * FROM material WHERE id=?")
.bind(mat_id)
.fetch_one(&self.pool)
.await?;
Ok(Material {
id: pret.id,
name: pret.name,
category: self.get_mcat_by_id(pret.category_id).await.unwrap(),
quantity: pret.quantity,
})
}
pub async fn get_mcat_by_id(&self, mcat_id: i32) -> Result<MaterialCategory, sqlx::Error> {
sqlx::query_as::<_, MaterialCategory>("SELECT * FROM material_category WHERE id=?")
.bind(mcat_id)
.fetch_one(&self.pool)
.await
}
pub async fn update_recipe(&self, recipe: Recipe) -> Result<bool, sqlx::Error> {
match sqlx::query("UPDATE `recipe` SET name=? WHERE id=?;")
.bind(recipe.name)
@ -605,10 +636,9 @@ impl DBOperator {
.fetch_all(&self.pool)
.await;
let mats = self.get_materials().await.unwrap();
let mut ret: Vec<RecipeElement> = Vec::new();
for re in pre_ret.unwrap().iter() {
let mat = mats.iter().find(|m| m.id == re.material_id);
let mat = self.get_mat_by_id(re.material_id).await.ok();
let eq = self.get_equipment_by_id(re.equipment_id).await.ok();
match (mat, eq) {
(Some(m), Some(e)) => {
@ -704,7 +734,7 @@ impl DBOperator {
ret
}
pub async fn get_client_by_id(&self, id: i32) -> Result<Client, sqlx::Error> {
sqlx::query_as::<_, Client>("SELECT FROM `client` WHERE id=?")
sqlx::query_as::<_, Client>("SELECT * FROM `client` WHERE id=?")
.bind(id)
.fetch_one(&self.pool)
.await
@ -789,6 +819,107 @@ 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_elems: BTreeSet<OrderElement>,
order_id: i32,
) -> Result<(), sqlx::Error> {
let mut tx = self.pool.begin().await?;
for el in order_elems.iter() {
sqlx::query("INSERT INTO order_element (order_id, product_id, quantity, total_amount) VALUES(?, ?, ?, ?);")
.bind(order_id)
.bind(el.product.id)
.bind(el.quantity)
.bind(el.total_price.clone())
.execute(&mut *tx).await;
}
match tx.commit().await {
Ok(_) => Ok(()),
Err(e) => Err(e),
}
}
pub async fn remove_order_elements(&self, order_id: i32) -> Result<(), sqlx::Error> {
match sqlx::query("DELETE FROM order_element WHERE order_id=?")
.bind(order_id)
.execute(&self.pool)
.await
{
Ok(_) => Ok(()),
Err(e) => Err(e),
}
}
pub async fn add_order(&self, order: Order, incoming: bool) -> Result<i32, sqlx::Error> {
let res = sqlx::query("INSERT INTO `order` (client_id, order_date, total_price, is_incoming) VALUES(?, ?, ?, ?);").bind(order.client.id).bind(order.order_date).bind(order.total_price).bind(incoming).execute(&self.pool).await?;
Ok(res.last_insert_id().to_i32().unwrap())
}
pub async fn update_order(&self, order: Order, incoming: bool) -> Result<(), sqlx::Error> {
match sqlx::query("UPDATE `order` SET client_id=?, order_date=?, total_price=?, is_incoming=? WHERE id=?;").bind(order.client.id).bind(order.order_date).bind(order.total_price).bind(incoming).bind(order.id).execute(&self.pool).await{
Ok(_) => Ok(()),
Err(e) => Err(e)
}
}
pub async fn remove_order(&self, order_id: i32) -> Result<(), sqlx::Error> {
match sqlx::query("DELETE FROM `order` WHERE id=?")
.bind(order_id)
.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();

21
code/src/material_tab.rs
View File

@ -5,6 +5,7 @@ use egui_extras::{Column, TableBuilder};
use crate::{
database::DBOperator,
misc::ELEMENTS_PER_PAGE,
models::{Material, MaterialCategory, MaterialRow, ModalStatus, ModalWinState},
tab::{TABS_CAN_BE_WINDOWS, Tab, TabTypes},
};
@ -19,6 +20,8 @@ pub struct MaterialTabViewer {
mat_cats: Arc<RwLock<Vec<MaterialCategory>>>,
mats: Arc<RwLock<Vec<Material>>>,
is_admin: bool,
mat_page: i32,
mcat_page: i32,
}
impl MaterialTabViewer {
pub fn new(is_admin: bool) -> Self {
@ -34,10 +37,12 @@ impl MaterialTabViewer {
));
}
fn update_materials(&mut self) {
self.mats = Arc::new(RwLock::new(
self.rt
.block_on(async { self.db_oper.get_materials().await.unwrap() }),
));
self.mats = Arc::new(RwLock::new(self.rt.block_on(async {
self.db_oper
.get_materials(self.mat_page * ELEMENTS_PER_PAGE, ELEMENTS_PER_PAGE)
.await
.unwrap()
})));
}
fn show_material(&mut self, ui: &mut egui::Ui) {
ui.horizontal(|ui| {
@ -546,9 +551,9 @@ impl Default for MaterialTabViewer {
let mat_cats = Arc::new(RwLock::new(
rt.block_on(async { db_oper.get_mcat().await.unwrap() }),
));
let mats = Arc::new(RwLock::new(
rt.block_on(async { db_oper.get_materials().await.unwrap() }),
));
let mats = Arc::new(RwLock::new(rt.block_on(async {
db_oper.get_materials(0, ELEMENTS_PER_PAGE).await.unwrap()
})));
Self {
db_oper,
rt,
@ -588,6 +593,8 @@ impl Default for MaterialTabViewer {
mat_cats,
mats,
is_admin: false,
mat_page: 0,
mcat_page: 0,
}
}
}

13
code/src/models.rs
View File

@ -125,13 +125,13 @@ 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,
pub address: String,
}
#[derive(Default, PartialEq, PartialOrd, Eq, Ord)]
#[derive(Default, PartialEq, PartialOrd, Eq, Ord, Clone)]
pub struct Order {
pub id: i32,
pub client: Client,
@ -159,7 +159,6 @@ pub struct OrderElementRow {
pub product_id: i32,
pub quantity: i32,
pub total_price: BigDecimal,
pub is_incoming: bool,
}
#[derive(Default, Clone, PartialEq, Eq, Hash, PartialOrd, Ord)]
pub struct Product {
@ -213,6 +212,7 @@ pub struct WorkerModalState {
pub worker: Worker,
pub status: ModalStatus,
pub old_pos: Position,
pub old_fired: bool,
}
#[derive(Default)]
@ -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 {

330
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;
}
});
});
}
@ -93,6 +178,7 @@ impl OrderTabViewer {
ui.horizontal(|ui| {
if self.is_admin {
if ui.button("Добавить").clicked() {
self.update_clients();
self.process_order_state.is_open = true;
self.process_order_state.order = Order::default();
}
@ -100,12 +186,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();
}
@ -141,9 +227,9 @@ impl OrderTabViewer {
.header(25.0, |mut heading| {
heading.col(|ui| {
ui.heading(if incoming_orders {
"Заказчик"
"Заказчик "
} else {
"Клиент"
"Клиент "
});
});
heading.col(|ui| {
@ -155,9 +241,13 @@ impl OrderTabViewer {
heading.col(|ui| {
ui.heading("Дата создания");
});
heading.col(|ui| {
ui.heading(" ");
});
})
.body(|mut body| {
for or in orders.read().iter() {
body.ui_mut().style_mut().interaction.selectable_labels = false;
body.row(25.0, |mut row| {
let len = orders.read().iter().clone().len();
row.col(|ui| {
@ -175,7 +265,21 @@ impl OrderTabViewer {
row.col(|ui| {
ui.label(or.order_date.date_naive().to_string());
});
row.col(|ui| if ui.button("Удалить").clicked() {});
if self.is_admin {
row.col(|ui| {
if ui.button("Удалить").clicked() {
self.process_order_state.is_open = true;
self.process_order_state.order = or.clone();
self.process_order_state.status = ModalStatus::Remove;
}
});
if row.response().double_clicked() {
self.update_clients();
self.process_order_state.is_open = true;
self.process_order_state.order = or.clone();
self.process_order_state.status = ModalStatus::Edit;
}
}
});
}
});
@ -185,53 +289,177 @@ impl OrderTabViewer {
self.process_order_state.is_open = false
}
egui::Grid::new("order_process_grid").show(ui, |ui| {
ui.label("ID заказа:");
ui.label(self.process_order_state.order.id.to_string());
ui.end_row();
ui.label(if incoming_orders {
"Заказчик"
} else {
"Клиент"
});
//ВЫБОР КЛИЕНТА
ui.end_row();
ui.label("Элементы");
egui::ComboBox::new("order_process_combobox", "")
.close_behavior(egui::PopupCloseBehavior::CloseOnClickOutside)
.selected_text(match self.process_order_state.order.elements.len() {
0 => "Пусто".to_owned(),
_ => format!("{} элем.", self.process_order_state.order.elements.len()),
})
.show_ui(ui, |ui| {
if ui.button("Новый элемент").clicked() {
self.process_element_state.is_open = true;
self.process_element_state.status = ModalStatus::Add;
self.process_element_state.element = OrderElement::default();
}
for el in self.process_order_state.order.elements.clone().iter() {
ui.horizontal(|ui| {
if ui.button("x").clicked() {
self.process_order_state.order.elements.remove(el);
}
ui.label(format!(
"{} ({})\n{}/шт.",
el.product.recipe.name,
el.quantity,
el.product.price_per_unit
));
});
}
if self.process_order_state.status != ModalStatus::Add {
ui.label("ID заказа:");
ui.label(self.process_order_state.order.id.to_string());
ui.end_row();
}
if self.process_order_state.status != ModalStatus::Remove {
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.horizontal(|ui| {
if ui.button("<-").clicked() {
if self.client_page > 0 {
self.client_page -= 1;
}
}
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;
}
}
});
for cl in self.clients.read().iter() {
ui.selectable_value(
&mut self.process_order_state.order.client,
cl.clone(),
&cl.name,
);
}
});
ui.end_row();
ui.label("Элементы");
egui::ComboBox::new("order_process_combobox", "")
.close_behavior(egui::PopupCloseBehavior::CloseOnClickOutside)
.selected_text(match self.process_order_state.order.elements.len() {
0 => "Пусто".to_owned(),
_ => format!(
"{} элем.",
self.process_order_state.order.elements.len()
),
})
.show_ui(ui, |ui| {
if ui.button("Новый элемент").clicked() {
self.process_element_state.is_open = true;
self.process_element_state.status = ModalStatus::Add;
self.process_element_state.element = OrderElement::default();
}
for el in self.process_order_state.order.elements.clone().iter() {
ui.horizontal(|ui| {
if ui.button("x").clicked() {
self.process_order_state.order.elements.remove(el);
}
ui.label(format!(
"{} ({})\n{}/шт.",
el.product.recipe.name,
el.quantity,
el.product.price_per_unit
));
});
}
});
ui.end_row();
ui.label("Дата заказа: ");
let ndate = self.process_order_state.order.order_date.date_naive();
let mut date = misc::naivedate_to_jiff(ndate);
ui.add(egui_extras::DatePickerButton::new(&mut date));
if self.process_order_state.order.order_date.date_naive()
!= misc::jiff_to_naivedate(date)
{
self.process_order_state.order.order_date =
misc::jiff_to_naivedate(date)
.and_hms_opt(0, 0, 0)
.unwrap()
.and_local_timezone(chrono::Local)
.unwrap();
}
}
});
let btext = match self.process_order_state.status {
ModalStatus::Add => "Добавить",
ModalStatus::Edit => "Сохранить",
ModalStatus::Remove => "Удалить",
};
self.process_order_state.can_finish = match self.process_order_state.status {
ModalStatus::Remove => true,
_ => {
self.process_order_state.order.client.name.len() > 0
&& self.process_order_state.order.elements.len() > 0
}
};
if ui
.add_enabled(
self.process_order_state.can_finish,
egui::Button::new(btext),
)
.clicked()
{
self.rt.block_on(async {
match self.process_order_state.status {
ModalStatus::Add => {
let id = self
.db_oper
.add_order(
self.process_order_state.order.clone(),
incoming_orders,
)
.await
.unwrap();
self.db_oper
.add_order_element(
self.process_order_state.order.elements.clone(),
id,
)
.await;
}
ModalStatus::Edit => {
self.db_oper
.remove_order_elements(self.process_order_state.order.id)
.await;
self.db_oper
.update_order(
self.process_order_state.order.clone(),
incoming_orders,
)
.await;
self.db_oper
.add_order_element(
self.process_order_state.order.elements.clone(),
self.process_order_state.order.id,
)
.await;
}
ModalStatus::Remove => {
self.db_oper
.remove_order_elements(self.process_order_state.order.id)
.await;
self.db_oper
.remove_order(self.process_order_state.order.id)
.await;
}
}
});
self.update_orders();
self.process_order_state.is_open = false;
}
});
}
if self.process_element_state.is_open {
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 +501,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,

42
code/src/recipe_tab.rs
View File

@ -3,10 +3,10 @@ use egui_extras::{Column, TableBuilder};
use crate::{
database::DBOperator,
misc,
misc::{self, ELEMENTS_PER_PAGE},
models::{
RecipeElementModalState, Equipment, Material, ModalStatus, Product, ProductModalState, Recipe,
RecipeElement, RecipeModalState,
Equipment, Material, ModalStatus, Product, ProductModalState, Recipe, RecipeElement,
RecipeElementModalState, RecipeModalState,
},
tab::{self, Tab, TabTypes},
};
@ -34,6 +34,7 @@ pub struct RecipeTabViewer {
old_price: BigDecimal,
product_page: i32,
recipe_page: i32,
mat_page: i32,
}
impl RecipeTabViewer {
@ -68,6 +69,21 @@ impl RecipeTabViewer {
egui::ComboBox::new("material_select_combobox", "")
.selected_text(&self.process_element_status.element.material.name)
.show_ui(ui, |ui| {
if ui.button("<-").clicked() {
if self.mat_page > 0 {
self.mat_page -= 1;
self.update_materials();
}
}
ui.monospace(self.mat_page.to_string());
if ui.button("->").clicked() {
if self.materials.read().len().to_i32().unwrap()
== misc::ELEMENTS_PER_PAGE
{
self.mat_page += 1;
self.update_materials();
}
}
for mat in self.materials.read().clone().iter() {
ui.selectable_value(
&mut self.process_element_status.element.material,
@ -370,6 +386,15 @@ impl RecipeTabViewer {
}
});
}
fn update_materials(&mut self) {
self.materials = Arc::new(RwLock::new(self.rt.block_on(async {
self.db_oper
.get_materials(self.mat_page, ELEMENTS_PER_PAGE)
.await
.unwrap_or(Vec::new())
})))
}
}
impl egui_dock::TabViewer for RecipeTabViewer {
type Tab = Tab;
@ -499,9 +524,12 @@ impl Default for RecipeTabViewer {
.await
.unwrap_or(Vec::new())
}))),
materials: Arc::new(RwLock::new(
rt.block_on(async { db_oper.get_materials().await.unwrap_or(Vec::new()) }),
)),
materials: Arc::new(RwLock::new(rt.block_on(async {
db_oper
.get_materials(0, ELEMENTS_PER_PAGE)
.await
.unwrap_or(Vec::new())
}))),
equipment: Arc::new(RwLock::new(rt.block_on(async {
db_oper
.get_equipment(0, 5, false)
@ -530,7 +558,7 @@ impl Default for RecipeTabViewer {
product_page: 0,
recipe_page: 0,
mat_page: 0,
rt,
db_oper,
}

130
code/src/worker_tab.rs
View File

@ -1,4 +1,4 @@
use bigdecimal::BigDecimal;
use bigdecimal::{BigDecimal, ToPrimitive};
use egui::mutex::RwLock;
use egui_extras::{Column, TableBuilder};
use std::collections::HashMap;
@ -26,6 +26,7 @@ pub struct WorkerTabViewer {
only_not_fired_workers: bool,
workers_page: i32,
positions_page: i32,
}
impl WorkerTabViewer {
@ -39,7 +40,7 @@ impl WorkerTabViewer {
self.workers = Arc::new(RwLock::new(self.rt.block_on(async {
self.db_oper
.get_workers(
self.workers_page,
self.workers_page * ELEMENTS_PER_PAGE,
ELEMENTS_PER_PAGE,
self.only_not_fired_workers,
)
@ -48,21 +49,42 @@ impl WorkerTabViewer {
})));
}
fn update_positions(&mut self) {
self.positions = Arc::new(RwLock::new(
self.rt
.block_on(async { self.db_oper.get_position().await.unwrap() }),
));
self.positions = Arc::new(RwLock::new(self.rt.block_on(async {
self.db_oper
.get_positions(self.positions_page * ELEMENTS_PER_PAGE, ELEMENTS_PER_PAGE)
.await
.unwrap()
})));
}
fn show_worker(&mut self, ui: &mut egui::Ui) {
ui.horizontal(|ui| {
if ui.button("Добавить").clicked() {
self.process_worker_state.is_open = true;
self.process_worker_state.worker = Worker::default();
};
if ui.button("Обновить").clicked() {
self.update_workers();
if self.is_admin {
if ui.button("Добавить").clicked() {
self.process_worker_state.is_open = true;
self.process_worker_state.worker = Worker::default();
};
}
if ui.button("<-").clicked() {
if self.workers_page > 0 {
self.workers_page -= 1;
self.update_workers();
}
}
ui.monospace(self.workers_page.to_string());
if ui.button("->").clicked() {
if self.workers.read().len().to_i32().unwrap() == misc::ELEMENTS_PER_PAGE {
self.workers_page += 1;
self.update_workers();
}
}
if ui
.checkbox(&mut self.only_not_fired_workers, "Без уволенных")
.changed()
{
self.update_workers();
};
});
if self.process_worker_state.is_open {
let pos = self.process_worker_state.worker.position.clone();
@ -90,6 +112,21 @@ impl WorkerTabViewer {
&self.process_worker_state.worker.position.name
})
.show_ui(ui, |ui| {
if ui.button("<-").clicked() {
if self.workers_page > 0 {
self.workers_page -= 1;
self.update_workers();
}
}
ui.monospace(self.workers_page.to_string());
if ui.button("->").clicked() {
if self.workers.read().len().to_i32().unwrap()
== misc::ELEMENTS_PER_PAGE
{
self.workers_page += 1;
self.update_workers();
}
}
for pos in self.positions.read().clone().iter() {
ui.selectable_value(
&mut self.process_worker_state.worker.position,
@ -165,6 +202,13 @@ impl WorkerTabViewer {
.await
.unwrap();
}
if self.process_worker_state.worker.is_fired
!= self.process_worker_state.old_fired
{
self.process_worker_state.worker.fire_date =
Some(chrono::Local::now());
}
self.db_oper
.update_worker(self.process_worker_state.worker.clone())
.await
@ -214,13 +258,18 @@ impl WorkerTabViewer {
ui.label(&wk.position.name);
});
row.col(|ui| {
ui.label(if wk.is_fired { "Да" } else { "Нет" });
ui.label(if wk.is_fired {
wk.fire_date.unwrap().date_naive().to_string()
} else {
"Нет".to_owned()
});
});
if row.response().double_clicked() {
self.process_worker_state.is_open = true;
self.process_worker_state.status = ModalStatus::Edit;
self.process_worker_state.worker = wk.clone();
self.process_worker_state.old_pos = wk.position.clone();
self.process_worker_state.old_fired = wk.is_fired.clone();
}
});
}
@ -229,22 +278,34 @@ impl WorkerTabViewer {
fn show_position(&mut self, ui: &mut egui::Ui) {
ui.horizontal(|ui| {
if ui.button("Добавить").clicked() {
// self.show_position_add_modal = true;
self.process_position_state.is_open = true;
self.process_position_state.status = ModalStatus::Add;
self.process_position_state
.data
.insert("id".into(), "0".to_string());
self.process_position_state
.data
.insert("name".into(), String::new());
self.process_position_state
.data
.insert("wage".into(), String::from("0"));
if self.is_admin {
if ui.button("Добавить").clicked() {
// self.show_position_add_modal = true;
self.process_position_state.is_open = true;
self.process_position_state.status = ModalStatus::Add;
self.process_position_state
.data
.insert("id".into(), "0".to_string());
self.process_position_state
.data
.insert("name".into(), String::new());
self.process_position_state
.data
.insert("wage".into(), String::from("0"));
}
}
if ui.button("Обновить").clicked() {
self.update_positions();
if ui.button("<-").clicked() {
if self.positions_page > 0 {
self.positions_page -= 1;
self.update_positions();
}
}
ui.monospace(self.positions_page.to_string());
if ui.button("->").clicked() {
if self.positions.read().len().to_i32().unwrap() == ELEMENTS_PER_PAGE {
self.positions_page += 1;
self.update_positions();
}
}
});
TableBuilder::new(ui)
@ -368,6 +429,7 @@ impl WorkerTabViewer {
match self.process_position_state.status {
ModalStatus::Add => {
let pos = self.process_position_state.data.clone();
self.rt.block_on(async {
self.db_oper
.add_position(Position {
@ -378,7 +440,8 @@ impl WorkerTabViewer {
)
.unwrap(),
})
.await;
.await
.unwrap();
})
}
ModalStatus::Edit => {
@ -488,9 +551,10 @@ impl Default for WorkerTabViewer {
fn default() -> Self {
let rt = tokio::runtime::Runtime::new().unwrap();
let db_oper = rt.block_on(async { DBOperator::new().await });
let positions = Arc::new(RwLock::new(
rt.block_on(async { db_oper.get_position().await.unwrap() }),
));
let positions =
Arc::new(RwLock::new(rt.block_on(async {
db_oper.get_positions(0, ELEMENTS_PER_PAGE).await.unwrap()
})));
let workers = Arc::new(RwLock::new(rt.block_on(async {
db_oper
.get_workers(0, misc::ELEMENTS_PER_PAGE, false)
@ -520,6 +584,7 @@ impl Default for WorkerTabViewer {
process_worker_state: WorkerModalState {
is_open: false,
can_finish: false,
old_fired: worker.is_fired,
worker,
status: ModalStatus::Add,
old_pos: Position::default(),
@ -533,6 +598,7 @@ impl Default for WorkerTabViewer {
is_admin: false,
only_not_fired_workers: false,
workers_page: 0,
positions_page: 0,
}
}
}

4
ЧЁСДЕЛАТЬ
View File

@ -1,4 +1,4 @@
1 - Добавить пагниацию там, где её ещё нет
2 - Доделать проверки при нажатии кнопок в модальных окнах
3 - Написать часть с клиентом
4 - доделать заказы
3 - Сделать отчёты