Backend Modules - Mardens-Inc/Pricing-App GitHub Wiki

HttpServer::new(move || {
    App::new()
        .app_data(web::Data::new(pool.clone()))
        .configure(inventory::configure)
        .configure(sheets::configure)
        .configure(list::configure)
        .configure(history::configure)
        .configure(pos_system::configure)
        .configure(icons_endpoint::configure)
        .configure(server_information::configure)
})

broadcast_inventory_update(
    &inventory_id,
    "record_updated",
    &record_id,
    &json!({"data": updated_record})
);

// Query across multiple columns
?query=shirt&query_columns=description,category&limit=50

?sort_by=date&sort_order=DESC&limit=50&offset=100

// inventory_endpoint.rs
#[utoipa::path(
    get,
    path = "/api/inventory/{id}",
    params(
        ("id" = String, Path, description = "Inventory ID"),
        InventoryFilterOptions
    ),
    responses((status = 200, description = "Inventory data"))
)]
pub async fn get_inventory_records(
    pool: web::Data<MySqlPool>,
    id: web::Path<String>,
    options: web::Query<InventoryFilterOptions>,
) -> Result<impl Responder> {
    let inv_id = decode_single(&id)?;
    let result = inventory_db::get_inventory(inv_id, Some(options.into_inner()), &data).await?;
    Ok(web::Json(result))
}

// Getting file path with correct extension
let file_path = get_file_path_with_extension(&identifier, &request)?;

// Parses file based on extension
if file_path.ends_with(".csv") {
    csv::parse_csv(&file_path)?
} else if file_path.ends_with(".xlsx") {
    excel::parse_excel(&file_path, sheet_name)?
} else {
    return Err(anyhow!("Unsupported file format"));
}

// templates/imperial_template.rs
pub struct ImperialTemplate {
    mappings: HashMap<String, String>,
}

// Maps spreadsheet columns to database columns
// Example: "Item Description" → "description"

pub fn parse_csv(path: &str) -> Result<Vec<HashMap<String, String>>> {
    let mut reader = csv::Reader::from_path(path)?;
    let headers = reader.headers()?.clone();

    let mut records = Vec::new();
    for result in reader.records() {
        let record = result?;
        let mut map = HashMap::new();
        for (i, field) in record.iter().enumerate() {
            map.insert(headers[i].to_string(), field.to_string());
        }
        records.push(map);
    }

    Ok(records)
}

use calamine::{open_workbook, Reader, Xlsx};

pub fn parse_excel(path: &str, sheet: &str) -> Result<Vec<HashMap<String, String>>> {
    let mut workbook: Xlsx<_> = open_workbook(path)?;
    let range = workbook.worksheet_range(sheet)?;

    let mut rows = range.rows();
    let headers = rows.next().ok_or(anyhow!("No headers"))?;

    let mut records = Vec::new();
    for row in rows {
        let mut map = HashMap::new();
        for (i, cell) in row.iter().enumerate() {
            map.insert(
                headers[i].to_string(),
                cell.to_string()
            );
        }
        records.push(map);
    }

    Ok(records)
}

UPDATE locations SET visible = false WHERE id = ?

// Delete location and all related tables
pub async fn delete_location(id: u64, pool: &MySqlPool) -> Result<()> {
    // Drop inventory table
    pool.execute(&format!("DROP TABLE IF EXISTS `{}`", id)).await?;

    // Drop related tables
    pool.execute(&format!("DROP TABLE IF EXISTS `columns_{}`", id)).await?;
    pool.execute(&format!("DROP TABLE IF EXISTS `options_{}`", id)).await?;

    // Delete location record
    sqlx::query("DELETE FROM locations WHERE id = ?")
        .bind(id)
        .execute(pool)
        .await?;

    Ok(())
}

{
    "field_name": {
        "old": "previous value",
        "new": "new value"
    }
}

// Record a change
history_db::create_entry(
    location_id,
    record_id,
    user_id,
    "updated",
    &json!({
        "price": {"old": "10.00", "new": "12.00"},
        "quantity": {"old": "5", "new": "10"}
    }),
    &pool
).await?;

// ftp_data.rs
use ftp::FtpStream;

pub struct FtpClient {
    host: String,
    user: String,
    password: String,
}

impl FtpClient {
    pub fn connect(&self) -> Result<FtpStream> {
        let mut ftp = FtpStream::connect(&self.host)?;
        ftp.login(&self.user, &self.password)?;
        Ok(ftp)
    }

    pub fn upload_file(&self, local_path: &str, remote_path: &str) -> Result<()> {
        let mut ftp = self.connect()?;
        let mut file = std::fs::File::open(local_path)?;
        ftp.put(remote_path, &mut file)?;
        ftp.quit()?;
        Ok(())
    }
}

const ICONS_FOLDER: &str = "icons";

// Save uploaded icon
let filename = sanitize_filename::sanitize(&user_filename);
let path = format!("{}/{}", ICONS_FOLDER, filename);
std::fs::write(&path, &bytes)?;

#[derive(Serialize)]
pub struct VersionInfo {
    pub version: String,
    pub build_date: String,
}

#[get("/api/server/version")]
pub async fn get_version() -> Result<impl Responder> {
    Ok(web::Json(VersionInfo {
        version: env!("CARGO_PKG_VERSION").to_string(),
        build_date: env!("BUILD_DATE").to_string(),
    }))
}