src/main.rs - master - aristeh/gui

src/main.rs
250 строк8 KB
aristeh
отправка сообщений
11 фев 2026, 14:05
11 фев 2026, 14:05e65862e
#![cfg_attr(not(debug_assertions), windows_subsystem = "windows")]
use rumqttc::QoS;
use std::error::Error;

slint::include_modules!();

mod broker;

mod db;

use gui::client;
use gui::models;
use rumqttc::{Client};
use std::sync::mpsc;
use std::sync::mpsc::{Receiver, Sender};
fn main() -> Result<(), Box<dyn Error>> {
    gui::start_broker(); // запустим брокер
    let _bd = gui::start_bd("mydb12.db").unwrap(); // запустим  клиента  базы данных

    // канал для сообщений  клиента mqtt  и  GUI
    let (tx_client, rx_client): (Sender<models::Message>, Receiver<models::Message>) =
        mpsc::channel();
    let mut c = client::start(&String::from("serg"), tx_client);
    c.subscribe(String::from("serg/form"), QoS::AtLeastOnce)
        .unwrap();
    c.subscribe(String::from("serg/widget"), QoS::AtLeastOnce)
        .unwrap();
    //tx.send(String::from("serg/form")).unwrap();
    let ui = AppWindow::new()?;
    ui.on_request_increase_value({
        let ui_handle = ui.as_weak();
        move || {
            let _ui = ui_handle.unwrap();
            //ui.set_counter(ui.get_counter() + 1);
            // // Вместо оригинального кода:
            send_form_query_request(&mut c, "1", "login");
            println!(
                "client Отправлено сообщение bd: {} ",
                "SELECT * FROM md_forms"
            );
        }
    });
    let ui_weak_for_channel = ui.as_weak();
    std::thread::spawn(move || {
        loop {
            if let Ok(received) = rx_client.recv() {
                // Process the received message directly as a models::Message
                let message = received;
                ui_weak_for_channel
                    .upgrade_in_event_loop(move |ui| match message {
                        models::Message::QueryResult(query_result) => {
                            println!(
                                "client Получен результат запроса: {} с статусом {:?}",
                                query_result.query_id, query_result.tip
                            );
                            ui.set_counter(33);
                        }
                        models::Message::ServerResult(server_result) => {
                            println!("Получен результат функции: {} ", server_result.id);
                            ui.set_counter(35);
                        }
                        _ => {
                            println!("client Unhandled event 1: ");
                        }
                    })
                    .unwrap();
            } else {
                // If deserialization fails, handle as a regular string
                ui_weak_for_channel
                    .upgrade_in_event_loop(move |ui| {
                        ui.set_counter(36);
                    })
                    .unwrap();
            }
        }
    });

    ui.run()?;

    Ok(())
}

fn send_form_query_request(mqtt_client: &mut Client, query_id: &str, search_pattern: &str) {
    // 1. Отправим запрос на получение форму с идентификатором query_id
    let message = models::Message::QueryRequest(models::QueryRequest {
        query_id: query_id.to_string(),
        sql: String::from("SELECT * FROM md_forms where name LIKE ?"),
        parameters: Some(serde_json::json!([search_pattern])),
        tip: String::from("форма"),
        response_topic: String::from("serg/form"),
        data: None,
    });

    let json_payload = serde_json::to_string(&message).unwrap();
    mqtt_client
        .publish(
            String::from("db/query"),
            QoS::AtLeastOnce,
            true,
            json_payload,
        )
        .unwrap();

    println!(
        "Отправлен запрос форм: SELECT * FROM md_forms WHERE name LIKE '{}'",
        search_pattern
    );
    
    // 2. Отправим запрос на получение виджетов с идентификатором query_id
    let message = models::Message::QueryRequest(models::QueryRequest {
        query_id: query_id.to_string(),
        sql: String::from("SELECT * FROM md_form_widgets where form_id = ?"),
        parameters: Some(serde_json::json!([query_id])),
        tip: String::from("виджет"),
        response_topic: String::from("serg/widget"),
        data: None,
    });

    let json_payload = serde_json::to_string(&message).unwrap();
    mqtt_client
        .publish(
            String::from("db/query"),
            QoS::AtLeastOnce,
            true,
            json_payload,
        )
        .unwrap();

    println!(
        "Отправлен запрос виджетов: SELECT * FROM md_widgets WHERE form_id = '{}'",
        query_id
    );
}

// // Prevent console window in addition to Slint window in Windows release builds when, e.g., starting the app via file manager. Ignored on other platforms.
// //

// #![cfg_attr(not(debug_assertions), windows_subsystem = "windows")]

// slint::include_modules!();

// //mod DataBase;

// mod data_base;
// //mod server;

// use std::error::Error;

// fn main() ->   Result<(), Box<dyn Error>> {
//     //Запуск сервера брокера MQTT
// //    let _ = broker::start_mqttd();

//   //  let _client_server = server::start_client()?;

//     //Запуск клиента MQTT базы данных
// //    data_base::start_client();

//     //Запуск клиента MQTT пользователя
//    // client::start_client();

//   //  let mut stmt =
//    //     conn.prepare("SELECT name, display, parent, id FROM my_database.main.md_subsystem;")?;
//   //  stmt.execute([])?;
//   //  println!("Column names: {:?}", stmt.column_names());
//   /*
//     let rbs: Vec<RecordBatch> = stmt.query_arrow([])?.collect();
//     println!("Column names: {:?}", stmt.column_names());

//     for person in &rbs {
//         println!("Found person {:?}", person["id"]);
//     }

//     let mut rows = stmt.query([])?;
//     while let Some(row) = rows.next()? {
//         println!("Found person {:?}", row.get::<usize, String>(0).unwrap());
//     }

//     print_batches(&rbs).unwrap();
// */
//     let ui = AppWindow::new()?;
//     ui.run()?;
//     Ok(())
// }

//use anyhow::Error;
//use odbc_api::{ConnectionOptions, Environment};

//const BATCH_SIZE: usize = 5000;
// use duckdb::{params, Connection, Result};

// In your project, we need to keep the arrow version same as the version used in duckdb.
// Refer to https://github.com/wangfenjin/duckdb-rs/issues/92
// You can either:
//use duckdb::arrow::record_batch::RecordBatch;
// Or in your Cargo.toml, use * as the version; features can be toggled according to your needs
// arrow = { version = "*", default-features = false, features = ["prettyprint"] }
// Then you can:
// use arrow::record_batch::RecordBatch;

//use duckdb::arrow::util::pretty::print_batches;

// #[derive(Debug)]
// struct Person {
//     id: i32,
//     name: String,
//     data: Option<Vec<u8>>,
// }

// Connect using a DSN. Alternatively we could have used a connection string
// let  connection = environment.connect(
//     "soqoldsn",
//     "SOQOL",
//     "SOQOL",
//     ConnectionOptions::default(),
// )?;
//fn main() -> Result<(), Error> {
//   let environment = Environment::new()?;
//   let connection_string = "
//   Driver={Soqol ODBC Driver};\
//   Server=localhost;\
//   UID=SOQOL;\
//   PWD=SOQOL;\
// //  URL=soqol://SOQOL:@0.0.0.0:2060/DB\
//   ";
//   let connection = environment
//       .connect_with_connection_string(connection_string, ConnectionOptions::default())?;
//   //   let query = "insert into PHONEtest values (897, 'Попов')";
//   let query = "select * from SYS._DATABASES;";
//   let parameters = (); // This query does not use any parameters.
//   let timeout_sec = None;
//   match  connection.execute(query, parameters, timeout_sec)? {

//   }
// let client = initmqttc();

//  let ui = AppWindow::new()?;
// ui.set_counter(1);
// ui.on_request_increase_value({
//     let ui_handle = ui.as_weak();
//     move || {
//         let ui = ui_handle.unwrap();
//         ui.set_counter(ui.get_counter() + 1);
//     }
// });

// ui.run()?;

//   Ok(())
//}   let query_result = stmt.query_arrow([]).unwrap();
//     eprintln!("RESULT: {:?}", query_result.collect::<Vec<_>>());