discount profiles and discounts overall implemented and working

src/app.rs

@@ -17,9 +17,9 @@ use std::{path::Path, sync::Arc};
 #[allow(unused_imports)]
 use crate::{
     controllers::{
-        account, admin_categories, admin_customers, admin_dashboard, admin_discounts, admin_form,
-        admin_orders, admin_products, admin_shipping, auth, auth_pages, cart, checkout, home, i18n,
-        media, oauth2,
+        account, admin_categories, admin_customers, admin_dashboard, admin_discount_profiles,
+        admin_discounts, admin_form, admin_orders, admin_products, admin_shipping, auth, auth_pages,
+        cart, checkout, home, i18n, media, oauth2,
         shop,
     },
     initializers,
@@ -106,6 +106,7 @@ impl Hooks for App {
             .add_route(admin_dashboard::routes())
             .add_route(admin_products::routes())
             .add_route(admin_discounts::routes())
+            .add_route(admin_discount_profiles::routes())
             .add_route(admin_categories::routes())
             .add_route(admin_orders::routes())
             .add_route(admin_customers::routes())

src/controllers/admin_customers.rs

@@ -1,24 +1,31 @@
-//! Admin management of business (company) accounts and their negotiated prices.
+//! Admin management of business (company) accounts and their pricing.
 //!
-//! Phase 1: list company accounts and, per account, set/clear a manually
-//! negotiated price per product ("personal agreement"). The effective price the
-//! business pays is always resolved by [`crate::shared::pricing`] (lowest of the
-//! public price and the negotiated price), shown here for reference.
+//! Per company the admin can: assign reusable discount profiles (the automated
+//! layer), resolve per-product collisions when two assigned profiles cover the
+//! same product, and set a manually negotiated price per product. The effective
+//! price the business pays is always resolved by [`crate::shared::pricing`]
+//! (lowest of public / automated / negotiated), shown here for reference.
 
-use std::collections::HashMap;
+use std::collections::{HashMap, HashSet};
 
 use axum_extra::extract::cookie::CookieJar;
 use loco_rs::prelude::*;
-use sea_orm::{ColumnTrait, EntityTrait, PaginatorTrait, QueryFilter, QueryOrder};
+use sea_orm::{
+    ActiveModelTrait, ColumnTrait, EntityTrait, IntoActiveModel, PaginatorTrait, QueryFilter,
+    QueryOrder, Set, TransactionTrait,
+};
 use serde::Deserialize;
 use serde_json::json;
 
 use crate::{
     controllers::i18n::current_lang,
-    models::{account_product_prices, products, _entities::users},
+    models::{
+        account_discount_profiles, account_product_prices, account_product_resolutions,
+        discount_profiles, products, _entities::users,
+    },
     shared::{
         guard,
-        money::{format_price, parse_price_to_cents},
+        money::{format_bp, format_price, parse_price_to_cents},
         pricing,
     },
 };
@@ -30,18 +37,32 @@ struct PriceForm {
     price: String,
 }
 
+#[derive(Debug, Deserialize)]
+struct ResolutionForm {
+    profile_id: i32,
+}
+
 async fn company_by_id(ctx: &AppContext, id: i32) -> Result<users::Model> {
     let user = users::Entity::find_by_id(id)
         .one(&ctx.db)
         .await?
         .ok_or_else(|| Error::NotFound)?;
-    // Negotiated pricing only applies to company accounts.
     if user.account_type != COMPANY {
         return Err(Error::NotFound);
     }
     Ok(user)
 }
 
+async fn assigned_profile_ids(ctx: &AppContext, user_id: i32) -> Result<HashSet<i32>> {
+    Ok(account_discount_profiles::Entity::find()
+        .filter(account_discount_profiles::Column::UserId.eq(user_id))
+        .all(&ctx.db)
+        .await?
+        .into_iter()
+        .map(|a| a.discount_profile_id)
+        .collect())
+}
+
 #[debug_handler]
 async fn index(
     auth: auth::JWT,
@@ -89,27 +110,58 @@ async fn show(
     guard::current_admin(auth, &ctx).await?;
     let company = company_by_id(&ctx, id).await?;
 
+    // All profiles (for the assignment section + name lookup) and which are
+    // assigned to this company.
+    let all_profiles = discount_profiles::Entity::find()
+        .order_by_asc(discount_profiles::Column::Name)
+        .all(&ctx.db)
+        .await?;
+    let assigned = assigned_profile_ids(&ctx, company.id).await?;
+    let profile_name: HashMap<i32, String> =
+        all_profiles.iter().map(|p| (p.id, p.name.clone())).collect();
+    let profiles_json: Vec<serde_json::Value> = all_profiles
+        .iter()
+        .map(|p| {
+            json!({
+                "id": p.id,
+                "name": p.name,
+                "percent": format_bp(p.percent_bp),
+                "scope_type": p.scope_type,
+                "assigned": assigned.contains(&p.id),
+            })
+        })
+        .collect();
+
     let list = products::Entity::find()
         .order_by_asc(products::Column::Name)
         .all(&ctx.db)
         .await?;
-    let priced = pricing::price_many(&ctx, &list, Some(&company)).await?;
-    let manual = account_product_prices::Model::map_for_user(&ctx.db, company.id).await?;
+    let details = pricing::detail_many(&ctx, &list, Some(&company)).await?;
 
     let rows: Vec<serde_json::Value> = list
         .iter()
-        .zip(priced.iter())
-        .map(|(product, priced)| {
+        .zip(details.iter())
+        .map(|(product, d)| {
+            let covering: Vec<serde_json::Value> = d
+                .covering_profile_ids
+                .iter()
+                .map(|pid| json!({ "id": pid, "name": profile_name.get(pid) }))
+                .collect();
             json!({
                 "product_id": product.id,
                 "name": product.name,
                 "currency": product.currency,
-                "regular_price": format_price(product.price_cents),
-                "public_price": format_price(product.effective_price_cents()),
+                "regular_price": format_price(d.regular_cents),
+                "public_price": format_price(d.public_cents),
                 "on_public_sale": product.on_sale(),
-                "manual_price": manual.get(&product.id).copied().map(format_price),
-                "effective_price": format_price(priced.price_cents),
-                "is_business": priced.is_business,
+                "manual_price": d.manual_cents.map(format_price),
+                "auto_price": d.auto_cents.map(format_price),
+                "auto_profile_name": d.auto_profile_id.and_then(|pid| profile_name.get(&pid)),
+                "auto_profile_id": d.auto_profile_id,
+                "collision": d.collision,
+                "covering": covering,
+                "effective_price": format_price(d.price_cents),
+                "is_business": d.is_business,
             })
         })
         .collect();
@@ -119,6 +171,7 @@ async fn show(
         "admin/customers/show.html",
         json!({
             "customer": { "id": company.id, "name": company.name, "email": company.email },
+            "profiles": profiles_json,
             "products": rows,
             "error": params.get("error"),
             "lang": current_lang(&jar),
@@ -137,7 +190,6 @@ async fn set_price(
     let company = company_by_id(&ctx, id).await?;
 
     let entered = form.price.trim().to_string();
-    // An empty value clears the negotiated price (same as the Remove action).
     if entered.is_empty() {
         account_product_prices::Model::clear(&ctx.db, company.id, product_id).await?;
         return format::redirect(&format!("/admin/customers/{id}"));
@@ -145,7 +197,11 @@ async fn set_price(
 
     let cents = match parse_price_to_cents(&entered) {
         Ok(cents) if cents > 0 => cents,
-        _ => return format::redirect(&format!("/admin/customers/{id}?error=discount-must-be-positive")),
+        _ => {
+            return format::redirect(&format!(
+                "/admin/customers/{id}?error=discount-must-be-positive"
+            ))
+        }
     };
     account_product_prices::Model::upsert(&ctx.db, company.id, product_id, cents).await?;
     format::redirect(&format!("/admin/customers/{id}"))
@@ -163,13 +219,82 @@ async fn remove_price(
     format::redirect(&format!("/admin/customers/{id}"))
 }
 
+/// Replace the company's assigned profiles with the submitted set of checkboxes
+/// (`profile_ids`, a repeated field axum `Form` can't collect, parsed directly).
+#[debug_handler]
+async fn sync_profiles(
+    auth: auth::JWT,
+    Path(id): Path<i32>,
+    State(ctx): State<AppContext>,
+    body: String,
+) -> Result<Response> {
+    guard::current_admin(auth, &ctx).await?;
+    let company = company_by_id(&ctx, id).await?;
+
+    let profile_ids: Vec<i32> = form_urlencoded::parse(body.as_bytes())
+        .filter(|(k, _)| k == "profile_ids")
+        .filter_map(|(_, v)| v.parse::<i32>().ok())
+        .collect();
+
+    let txn = ctx.db.begin().await?;
+    account_discount_profiles::Entity::delete_many()
+        .filter(account_discount_profiles::Column::UserId.eq(company.id))
+        .exec(&txn)
+        .await?;
+    for profile_id in profile_ids {
+        account_discount_profiles::ActiveModel {
+            user_id: Set(company.id),
+            discount_profile_id: Set(profile_id),
+            ..Default::default()
+        }
+        .insert(&txn)
+        .await?;
+    }
+    txn.commit().await?;
+    format::redirect(&format!("/admin/customers/{id}"))
+}
+
+/// Record the admin's chosen winning profile for a colliding product.
+#[debug_handler]
+async fn set_resolution(
+    auth: auth::JWT,
+    Path((id, product_id)): Path<(i32, i32)>,
+    State(ctx): State<AppContext>,
+    Form(form): Form<ResolutionForm>,
+) -> Result<Response> {
+    guard::current_admin(auth, &ctx).await?;
+    let company = company_by_id(&ctx, id).await?;
+
+    let existing = account_product_resolutions::Entity::find()
+        .filter(account_product_resolutions::Column::UserId.eq(company.id))
+        .filter(account_product_resolutions::Column::ProductId.eq(product_id))
+        .one(&ctx.db)
+        .await?;
+    let mut active = match existing {
+        Some(row) => row.into_active_model(),
+        None => account_product_resolutions::ActiveModel {
+            user_id: Set(company.id),
+            product_id: Set(product_id),
+            ..Default::default()
+        },
+    };
+    active.discount_profile_id = Set(form.profile_id);
+    active.save(&ctx.db).await?;
+    format::redirect(&format!("/admin/customers/{id}"))
+}
+
 pub fn routes() -> Routes {
     Routes::new()
         .add("/admin/customers", get(index))
         .add("/admin/customers/{id}", get(show))
+        .add("/admin/customers/{id}/profiles", post(sync_profiles))
         .add("/admin/customers/{id}/prices/{product_id}", post(set_price))
         .add(
             "/admin/customers/{id}/prices/{product_id}/remove",
             post(remove_price),
         )
+        .add(
+            "/admin/customers/{id}/resolutions/{product_id}",
+            post(set_resolution),
+        )
 }

src/controllers/admin_discount_profiles.rs

@@ -0,0 +1,298 @@
+//! Admin CRUD for reusable discount profiles (a named percentage over a product
+//! scope). Profiles are assigned to business accounts on the customer page; here
+//! the admin only defines them.
+
+use std::collections::HashSet;
+
+use axum_extra::extract::cookie::CookieJar;
+use loco_rs::prelude::*;
+use sea_orm::{
+    ActiveModelTrait, ColumnTrait, EntityTrait, IntoActiveModel, ModelTrait, PaginatorTrait,
+    QueryFilter, QueryOrder, Set, TransactionTrait,
+};
+use serde_json::json;
+
+use crate::{
+    controllers::i18n::current_lang,
+    models::{discount_profile_products, discount_profiles, products},
+    shared::{
+        guard,
+        money::{format_bp, parse_percent, percent_to_bp},
+    },
+};
+
+/// Scalar + repeated fields parsed from the profile form. `product_ids` is a
+/// repeated checkbox field, which `serde_urlencoded` (axum `Form`) can't collect,
+/// so the body is parsed directly.
+struct ProfileInput {
+    name: String,
+    percent: String,
+    scope_type: String,
+    product_ids: Vec<i32>,
+}
+
+fn parse_profile_form(body: &str) -> ProfileInput {
+    let mut name = String::new();
+    let mut percent = String::new();
+    let mut scope_type = discount_profiles::SCOPE_INCLUDE.to_string();
+    let mut product_ids = Vec::new();
+    for (key, value) in form_urlencoded::parse(body.as_bytes()) {
+        match key.as_ref() {
+            "name" => name = value.into_owned(),
+            "percent" => percent = value.into_owned(),
+            "scope_type" => scope_type = value.into_owned(),
+            "product_ids" => {
+                if let Ok(id) = value.parse::<i32>() {
+                    product_ids.push(id);
+                }
+            }
+            _ => {}
+        }
+    }
+    ProfileInput {
+        name,
+        percent,
+        scope_type,
+        product_ids,
+    }
+}
+
+async fn profile_by_id(ctx: &AppContext, id: i32) -> Result<discount_profiles::Model> {
+    discount_profiles::Entity::find_by_id(id)
+        .one(&ctx.db)
+        .await?
+        .ok_or_else(|| Error::NotFound)
+}
+
+#[debug_handler]
+async fn index(
+    auth: auth::JWT,
+    jar: CookieJar,
+    ViewEngine(v): ViewEngine<TeraView>,
+    State(ctx): State<AppContext>,
+) -> Result<Response> {
+    guard::current_admin(auth, &ctx).await?;
+    let profiles = discount_profiles::Entity::find()
+        .order_by_asc(discount_profiles::Column::Name)
+        .all(&ctx.db)
+        .await?;
+
+    let mut rows = Vec::with_capacity(profiles.len());
+    for profile in &profiles {
+        let count = discount_profile_products::Entity::find()
+            .filter(discount_profile_products::Column::DiscountProfileId.eq(profile.id))
+            .count(&ctx.db)
+            .await?;
+        rows.push(json!({
+            "id": profile.id,
+            "name": profile.name,
+            "percent": format_bp(profile.percent_bp),
+            "scope_type": profile.scope_type,
+            "product_count": count,
+        }));
+    }
+
+    format::view(
+        &v,
+        "admin/catalog/discount_profiles.html",
+        json!({ "profiles": rows, "lang": current_lang(&jar) }),
+    )
+}
+
+/// Render the create/edit form. `profile` is null on create.
+async fn render_form(
+    ctx: &AppContext,
+    v: &TeraView,
+    jar: &CookieJar,
+    profile: Option<&discount_profiles::Model>,
+    selected: &HashSet<i32>,
+    error: Option<&str>,
+) -> Result<Response> {
+    let all_products = products::Entity::find()
+        .order_by_asc(products::Column::Name)
+        .all(&ctx.db)
+        .await?;
+    let product_rows: Vec<serde_json::Value> = all_products
+        .iter()
+        .map(|p| json!({ "id": p.id, "name": p.name, "selected": selected.contains(&p.id) }))
+        .collect();
+
+    let profile_json = match profile {
+        Some(p) => json!({
+            "id": p.id,
+            "name": p.name,
+            "percent": format_bp(p.percent_bp),
+            "scope_type": p.scope_type,
+        }),
+        None => serde_json::Value::Null,
+    };
+
+    format::view(
+        v,
+        "admin/catalog/discount_profile_form.html",
+        json!({
+            "profile": profile_json,
+            "products": product_rows,
+            "error": error,
+            "lang": current_lang(jar),
+        }),
+    )
+}
+
+#[debug_handler]
+async fn new(
+    auth: auth::JWT,
+    jar: CookieJar,
+    ViewEngine(v): ViewEngine<TeraView>,
+    State(ctx): State<AppContext>,
+) -> Result<Response> {
+    guard::current_admin(auth, &ctx).await?;
+    render_form(&ctx, &v, &jar, None, &HashSet::new(), None).await
+}
+
+#[debug_handler]
+async fn edit(
+    auth: auth::JWT,
+    jar: CookieJar,
+    ViewEngine(v): ViewEngine<TeraView>,
+    Path(id): Path<i32>,
+    State(ctx): State<AppContext>,
+) -> Result<Response> {
+    guard::current_admin(auth, &ctx).await?;
+    let profile = profile_by_id(&ctx, id).await?;
+    let selected = member_ids(&ctx, id).await?;
+    render_form(&ctx, &v, &jar, Some(&profile), &selected, None).await
+}
+
+async fn member_ids(ctx: &AppContext, profile_id: i32) -> Result<HashSet<i32>> {
+    Ok(discount_profile_products::Entity::find()
+        .filter(discount_profile_products::Column::DiscountProfileId.eq(profile_id))
+        .all(&ctx.db)
+        .await?
+        .into_iter()
+        .map(|r| r.product_id)
+        .collect())
+}
+
+/// Validate the parsed form into `(name, percent_bp, scope_type)`, or an error key.
+fn validate(input: &ProfileInput) -> std::result::Result<(String, i32, String), &'static str> {
+    let name = input.name.trim().to_string();
+    if name.is_empty() {
+        return Err("profile-name-required");
+    }
+    let pct = parse_percent(&input.percent).ok_or("discount-invalid")?;
+    if pct <= 0.0 || pct >= 100.0 {
+        return Err("discount-percent-range");
+    }
+    let scope = if input.scope_type == discount_profiles::SCOPE_ALL_EXCEPT {
+        discount_profiles::SCOPE_ALL_EXCEPT
+    } else {
+        discount_profiles::SCOPE_INCLUDE
+    };
+    Ok((name, percent_to_bp(pct), scope.to_string()))
+}
+
+/// Replace a profile's product membership with `product_ids`.
+async fn sync_membership(
+    ctx: &AppContext,
+    profile_id: i32,
+    product_ids: &[i32],
+) -> Result<()> {
+    let txn = ctx.db.begin().await?;
+    discount_profile_products::Entity::delete_many()
+        .filter(discount_profile_products::Column::DiscountProfileId.eq(profile_id))
+        .exec(&txn)
+        .await?;
+    for product_id in product_ids {
+        discount_profile_products::ActiveModel {
+            discount_profile_id: Set(profile_id),
+            product_id: Set(*product_id),
+            ..Default::default()
+        }
+        .insert(&txn)
+        .await?;
+    }
+    txn.commit().await?;
+    Ok(())
+}
+
+#[debug_handler]
+async fn create(
+    auth: auth::JWT,
+    jar: CookieJar,
+    ViewEngine(v): ViewEngine<TeraView>,
+    State(ctx): State<AppContext>,
+    body: String,
+) -> Result<Response> {
+    guard::current_admin(auth, &ctx).await?;
+    let input = parse_profile_form(&body);
+    let (name, percent_bp, scope_type) = match validate(&input) {
+        Ok(values) => values,
+        Err(key) => {
+            let selected: HashSet<i32> = input.product_ids.iter().copied().collect();
+            return render_form(&ctx, &v, &jar, None, &selected, Some(key)).await;
+        }
+    };
+
+    let profile = discount_profiles::ActiveModel {
+        name: Set(name),
+        percent_bp: Set(percent_bp),
+        scope_type: Set(scope_type),
+        ..Default::default()
+    }
+    .insert(&ctx.db)
+    .await?;
+    sync_membership(&ctx, profile.id, &input.product_ids).await?;
+    format::redirect("/admin/catalog/discount-profiles")
+}
+
+#[debug_handler]
+async fn update(
+    auth: auth::JWT,
+    jar: CookieJar,
+    ViewEngine(v): ViewEngine<TeraView>,
+    Path(id): Path<i32>,
+    State(ctx): State<AppContext>,
+    body: String,
+) -> Result<Response> {
+    guard::current_admin(auth, &ctx).await?;
+    let profile = profile_by_id(&ctx, id).await?;
+    let input = parse_profile_form(&body);
+    let (name, percent_bp, scope_type) = match validate(&input) {
+        Ok(values) => values,
+        Err(key) => {
+            let selected: HashSet<i32> = input.product_ids.iter().copied().collect();
+            return render_form(&ctx, &v, &jar, Some(&profile), &selected, Some(key)).await;
+        }
+    };
+
+    let mut active = profile.into_active_model();
+    active.name = Set(name);
+    active.percent_bp = Set(percent_bp);
+    active.scope_type = Set(scope_type);
+    active.update(&ctx.db).await?;
+    sync_membership(&ctx, id, &input.product_ids).await?;
+    format::redirect("/admin/catalog/discount-profiles")
+}
+
+#[debug_handler]
+async fn delete(
+    auth: auth::JWT,
+    Path(id): Path<i32>,
+    State(ctx): State<AppContext>,
+) -> Result<Response> {
+    guard::current_admin(auth, &ctx).await?;
+    // FK cascades remove membership, assignments and resolutions.
+    profile_by_id(&ctx, id).await?.delete(&ctx.db).await?;
+    format::redirect("/admin/catalog/discount-profiles")
+}
+
+pub fn routes() -> Routes {
+    Routes::new()
+        .add("/admin/catalog/discount-profiles", get(index))
+        .add("/admin/catalog/discount-profiles/new", get(new))
+        .add("/admin/catalog/discount-profiles", post(create))
+        .add("/admin/catalog/discount-profiles/{id}/edit", get(edit))
+        .add("/admin/catalog/discount-profiles/{id}", post(update))
+        .add("/admin/catalog/discount-profiles/{id}/delete", post(delete))
+}

src/controllers/admin_discounts.rs

@@ -16,7 +16,7 @@ use crate::{
     models::products,
     shared::{
         guard,
-        money::{format_price, parse_price_to_cents},
+        money::{format_price, parse_percent, parse_price_to_cents},
     },
 };
 
@@ -29,12 +29,6 @@ struct DiscountForm {
     percent: Option<String>,
 }
 
-/// Parse a percentage typed as "20", "20.5" or "20,5" into an `f64`.
-fn parse_percent(value: &str) -> Option<f64> {
-    let parsed: f64 = value.trim().replace(',', ".").parse().ok()?;
-    parsed.is_finite().then_some(parsed)
-}
-
 /// Resolve a percentage off the regular price into a fixed sale price in cents.
 /// Rounds the discount amount to the nearest cent.
 fn percent_to_sale_cents(regular_cents: i64, percent: f64) -> i64 {

src/controllers/mod.rs

@@ -5,6 +5,7 @@ pub mod oauth2;
 pub mod admin_categories;
 pub mod admin_customers;
 pub mod admin_dashboard;
+pub mod admin_discount_profiles;
 pub mod admin_discounts;
 pub mod admin_form;
 pub mod admin_orders;

src/models/_entities/account_discount_profiles.rs

@@ -0,0 +1,48 @@
+//! `SeaORM` Entity assigning a discount profile to a business account.
+//! Hand-written to match the `account_discount_profiles` migration.
+
+use sea_orm::entity::prelude::*;
+use serde::{Deserialize, Serialize};
+
+#[derive(Clone, Debug, PartialEq, DeriveEntityModel, Eq, Serialize, Deserialize)]
+#[sea_orm(table_name = "account_discount_profiles")]
+pub struct Model {
+    pub created_at: DateTimeWithTimeZone,
+    pub updated_at: DateTimeWithTimeZone,
+    #[sea_orm(primary_key)]
+    pub id: i32,
+    pub user_id: i32,
+    pub discount_profile_id: i32,
+}
+
+#[derive(Copy, Clone, Debug, EnumIter, DeriveRelation)]
+pub enum Relation {
+    #[sea_orm(
+        belongs_to = "super::users::Entity",
+        from = "Column::UserId",
+        to = "super::users::Column::Id",
+        on_update = "Cascade",
+        on_delete = "Cascade"
+    )]
+    Users,
+    #[sea_orm(
+        belongs_to = "super::discount_profiles::Entity",
+        from = "Column::DiscountProfileId",
+        to = "super::discount_profiles::Column::Id",
+        on_update = "Cascade",
+        on_delete = "Cascade"
+    )]
+    DiscountProfiles,
+}
+
+impl Related<super::users::Entity> for Entity {
+    fn to() -> RelationDef {
+        Relation::Users.def()
+    }
+}
+
+impl Related<super::discount_profiles::Entity> for Entity {
+    fn to() -> RelationDef {
+        Relation::DiscountProfiles.def()
+    }
+}

src/models/_entities/account_product_resolutions.rs

@@ -0,0 +1,64 @@
+//! `SeaORM` Entity for an account's chosen profile when two assigned profiles
+//! cover one product. Hand-written to match the `account_product_resolutions`
+//! migration.
+
+use sea_orm::entity::prelude::*;
+use serde::{Deserialize, Serialize};
+
+#[derive(Clone, Debug, PartialEq, DeriveEntityModel, Eq, Serialize, Deserialize)]
+#[sea_orm(table_name = "account_product_resolutions")]
+pub struct Model {
+    pub created_at: DateTimeWithTimeZone,
+    pub updated_at: DateTimeWithTimeZone,
+    #[sea_orm(primary_key)]
+    pub id: i32,
+    pub user_id: i32,
+    pub product_id: i32,
+    pub discount_profile_id: i32,
+}
+
+#[derive(Copy, Clone, Debug, EnumIter, DeriveRelation)]
+pub enum Relation {
+    #[sea_orm(
+        belongs_to = "super::users::Entity",
+        from = "Column::UserId",
+        to = "super::users::Column::Id",
+        on_update = "Cascade",
+        on_delete = "Cascade"
+    )]
+    Users,
+    #[sea_orm(
+        belongs_to = "super::products::Entity",
+        from = "Column::ProductId",
+        to = "super::products::Column::Id",
+        on_update = "Cascade",
+        on_delete = "Cascade"
+    )]
+    Products,
+    #[sea_orm(
+        belongs_to = "super::discount_profiles::Entity",
+        from = "Column::DiscountProfileId",
+        to = "super::discount_profiles::Column::Id",
+        on_update = "Cascade",
+        on_delete = "Cascade"
+    )]
+    DiscountProfiles,
+}
+
+impl Related<super::users::Entity> for Entity {
+    fn to() -> RelationDef {
+        Relation::Users.def()
+    }
+}
+
+impl Related<super::products::Entity> for Entity {
+    fn to() -> RelationDef {
+        Relation::Products.def()
+    }
+}
+
+impl Related<super::discount_profiles::Entity> for Entity {
+    fn to() -> RelationDef {
+        Relation::DiscountProfiles.def()
+    }
+}

src/models/_entities/discount_profile_products.rs

@@ -0,0 +1,48 @@
+//! `SeaORM` Entity for a discount profile's product membership. Hand-written to
+//! match the `discount_profile_products` migration.
+
+use sea_orm::entity::prelude::*;
+use serde::{Deserialize, Serialize};
+
+#[derive(Clone, Debug, PartialEq, DeriveEntityModel, Eq, Serialize, Deserialize)]
+#[sea_orm(table_name = "discount_profile_products")]
+pub struct Model {
+    pub created_at: DateTimeWithTimeZone,
+    pub updated_at: DateTimeWithTimeZone,
+    #[sea_orm(primary_key)]
+    pub id: i32,
+    pub discount_profile_id: i32,
+    pub product_id: i32,
+}
+
+#[derive(Copy, Clone, Debug, EnumIter, DeriveRelation)]
+pub enum Relation {
+    #[sea_orm(
+        belongs_to = "super::discount_profiles::Entity",
+        from = "Column::DiscountProfileId",
+        to = "super::discount_profiles::Column::Id",
+        on_update = "Cascade",
+        on_delete = "Cascade"
+    )]
+    DiscountProfiles,
+    #[sea_orm(
+        belongs_to = "super::products::Entity",
+        from = "Column::ProductId",
+        to = "super::products::Column::Id",
+        on_update = "Cascade",
+        on_delete = "Cascade"
+    )]
+    Products,
+}
+
+impl Related<super::discount_profiles::Entity> for Entity {
+    fn to() -> RelationDef {
+        Relation::DiscountProfiles.def()
+    }
+}
+
+impl Related<super::products::Entity> for Entity {
+    fn to() -> RelationDef {
+        Relation::Products.def()
+    }
+}

src/models/_entities/discount_profiles.rs

@@ -0,0 +1,39 @@
+//! `SeaORM` Entity for reusable discount profiles. Hand-written to match the
+//! `discount_profiles` migration.
+
+use sea_orm::entity::prelude::*;
+use serde::{Deserialize, Serialize};
+
+#[derive(Clone, Debug, PartialEq, DeriveEntityModel, Eq, Serialize, Deserialize)]
+#[sea_orm(table_name = "discount_profiles")]
+pub struct Model {
+    pub created_at: DateTimeWithTimeZone,
+    pub updated_at: DateTimeWithTimeZone,
+    #[sea_orm(primary_key)]
+    pub id: i32,
+    pub name: String,
+    /// Discount in basis points (5% = 500).
+    pub percent_bp: i32,
+    /// "include" (covers listed products) or "all_except" (covers all but them).
+    pub scope_type: String,
+}
+
+#[derive(Copy, Clone, Debug, EnumIter, DeriveRelation)]
+pub enum Relation {
+    #[sea_orm(has_many = "super::discount_profile_products::Entity")]
+    DiscountProfileProducts,
+    #[sea_orm(has_many = "super::account_discount_profiles::Entity")]
+    AccountDiscountProfiles,
+}
+
+impl Related<super::discount_profile_products::Entity> for Entity {
+    fn to() -> RelationDef {
+        Relation::DiscountProfileProducts.def()
+    }
+}
+
+impl Related<super::account_discount_profiles::Entity> for Entity {
+    fn to() -> RelationDef {
+        Relation::AccountDiscountProfiles.def()
+    }
+}

src/models/_entities/mod.rs

@@ -2,9 +2,13 @@
 
 pub mod prelude;
 
+pub mod account_discount_profiles;
 pub mod account_product_prices;
+pub mod account_product_resolutions;
 pub mod audit_logs;
 pub mod categories;
+pub mod discount_profile_products;
+pub mod discount_profiles;
 pub mod customer_profiles;
 pub mod o_auth2_sessions;
 pub mod order_items;

src/models/_entities/prelude.rs

@@ -1,9 +1,13 @@
 //! `SeaORM` Entity, @generated by sea-orm-codegen 1.1.20
 
+pub use super::account_discount_profiles::Entity as AccountDiscountProfiles;
 pub use super::account_product_prices::Entity as AccountProductPrices;
+pub use super::account_product_resolutions::Entity as AccountProductResolutions;
 pub use super::audit_logs::Entity as AuditLogs;
 pub use super::categories::Entity as Categories;
 pub use super::customer_profiles::Entity as CustomerProfiles;
+pub use super::discount_profile_products::Entity as DiscountProfileProducts;
+pub use super::discount_profiles::Entity as DiscountProfiles;
 pub use super::o_auth2_sessions::Entity as OAuth2Sessions;
 pub use super::order_items::Entity as OrderItems;
 pub use super::orders::Entity as Orders;

src/models/account_discount_profiles.rs

@@ -0,0 +1,16 @@
+//! Assignment of a discount profile to a business account.
+
+pub use crate::models::_entities::account_discount_profiles::{ActiveModel, Column, Entity, Model};
+use sea_orm::entity::prelude::*;
+
+pub type AccountDiscountProfiles = Entity;
+
+#[async_trait::async_trait]
+impl ActiveModelBehavior for ActiveModel {
+    async fn before_save<C>(self, _db: &C, _insert: bool) -> std::result::Result<Self, DbErr>
+    where
+        C: ConnectionTrait,
+    {
+        Ok(self)
+    }
+}

src/models/account_product_resolutions.rs

@@ -0,0 +1,19 @@
+//! The chosen winning profile for an account+product when assigned profiles
+//! collide on that product.
+
+pub use crate::models::_entities::account_product_resolutions::{
+    ActiveModel, Column, Entity, Model,
+};
+use sea_orm::entity::prelude::*;
+
+pub type AccountProductResolutions = Entity;
+
+#[async_trait::async_trait]
+impl ActiveModelBehavior for ActiveModel {
+    async fn before_save<C>(self, _db: &C, _insert: bool) -> std::result::Result<Self, DbErr>
+    where
+        C: ConnectionTrait,
+    {
+        Ok(self)
+    }
+}

src/models/discount_profile_products.rs

@@ -0,0 +1,17 @@
+//! A discount profile's product membership (meaning depends on the profile's
+//! scope: included products, or excluded ones).
+
+pub use crate::models::_entities::discount_profile_products::{ActiveModel, Column, Entity, Model};
+use sea_orm::entity::prelude::*;
+
+pub type DiscountProfileProducts = Entity;
+
+#[async_trait::async_trait]
+impl ActiveModelBehavior for ActiveModel {
+    async fn before_save<C>(self, _db: &C, _insert: bool) -> std::result::Result<Self, DbErr>
+    where
+        C: ConnectionTrait,
+    {
+        Ok(self)
+    }
+}

src/models/discount_profiles.rs

@@ -0,0 +1,42 @@
+//! Reusable discount profiles: a named percentage over a product scope, mixable
+//! across business accounts.
+
+pub use crate::models::_entities::discount_profiles::{ActiveModel, Column, Entity, Model};
+use sea_orm::entity::prelude::*;
+
+pub type DiscountProfiles = Entity;
+
+/// Scope value: the profile covers exactly the listed products.
+pub const SCOPE_INCLUDE: &str = "include";
+/// Scope value: the profile covers every product except the listed ones.
+pub const SCOPE_ALL_EXCEPT: &str = "all_except";
+
+#[async_trait::async_trait]
+impl ActiveModelBehavior for ActiveModel {
+    async fn before_save<C>(self, _db: &C, insert: bool) -> std::result::Result<Self, DbErr>
+    where
+        C: ConnectionTrait,
+    {
+        if !insert && self.updated_at.is_unchanged() {
+            let mut this = self;
+            this.updated_at = sea_orm::ActiveValue::set(chrono::Utc::now().into());
+            Ok(this)
+        } else {
+            Ok(self)
+        }
+    }
+}
+
+impl Model {
+    /// A profile covers `product_id` when its scope lists the product (include)
+    /// or does not list it (all_except). `membership` is the profile's product
+    /// id set.
+    #[must_use]
+    pub fn covers(&self, product_id: i32, membership: &std::collections::HashSet<i32>) -> bool {
+        let listed = membership.contains(&product_id);
+        match self.scope_type.as_str() {
+            SCOPE_ALL_EXCEPT => !listed,
+            _ => listed,
+        }
+    }
+}

src/models/mod.rs

@@ -6,9 +6,13 @@
 
 pub mod _entities;
 
+pub mod account_discount_profiles;
 pub mod account_product_prices;
+pub mod account_product_resolutions;
 pub mod audit_logs;
 pub mod categories;
+pub mod discount_profile_products;
+pub mod discount_profiles;
 pub mod customer_profiles;
 pub mod o_auth2_sessions;
 pub mod order_items;

src/shared/money.rs

@@ -34,3 +34,41 @@ pub fn parse_price_to_cents(value: &str) -> Result<i64> {
 pub fn format_price(cents: i64) -> String {
     format!("{}.{:02}", cents / 100, (cents % 100).abs())
 }
+
+/// Parse a percentage typed as "20", "20.5" or "20,5" into an `f64`. Returns
+/// `None` for anything non-numeric or non-finite.
+#[must_use]
+pub fn parse_percent(value: &str) -> Option<f64> {
+    let parsed: f64 = value.trim().replace(',', ".").parse().ok()?;
+    parsed.is_finite().then_some(parsed)
+}
+
+/// Convert a percentage to basis points (5% -> 500), rounded to the nearest bp.
+#[must_use]
+pub fn percent_to_bp(percent: f64) -> i32 {
+    (percent * 100.0).round() as i32
+}
+
+/// Render basis points as a human percentage string, e.g. `550` -> `"5.5"`,
+/// `500` -> `"5"`.
+#[must_use]
+pub fn format_bp(bp: i32) -> String {
+    let whole = bp / 100;
+    let frac = (bp % 100).abs();
+    if frac == 0 {
+        whole.to_string()
+    } else if frac % 10 == 0 {
+        format!("{whole}.{}", frac / 10)
+    } else {
+        format!("{whole}.{frac:02}")
+    }
+}
+
+/// Apply a basis-point discount to a price in minor units, rounding the discount
+/// amount to the nearest cent. Never returns more than `cents`.
+#[must_use]
+pub fn apply_discount_bp(cents: i64, percent_bp: i32) -> i64 {
+    let bp = percent_bp.max(0) as i128;
+    let discount = (cents as i128 * bp + 5000) / 10000; // round half up
+    (cents - discount as i64).max(0)
+}

src/shared/pricing.rs

@@ -4,18 +4,25 @@
 //! Everyone sees the public price — the lower of the regular price and any
 //! public sale ([`products::Model::effective_price_cents`]). A logged-in
 //! **company** account additionally gets their business price: the lowest of the
-//! public price and any admin-set negotiated price. (Phase 2 will add automated
-//! discount profiles as a further input to the same "lowest wins" rule.)
+//! public price, any admin-set negotiated price, and the price from their
+//! assigned automated discount profiles. **Lowest wins.**
+
+use std::collections::{HashMap, HashSet};
 
 use loco_rs::prelude::*;
 use sea_orm::{ColumnTrait, EntityTrait, QueryFilter};
 
-use crate::models::{account_product_prices, products, users};
+use crate::models::{
+    account_discount_profiles, account_product_prices, account_product_resolutions,
+    discount_profile_products, discount_profiles, products, users,
+};
+use crate::shared::money::apply_discount_bp;
 
 /// `account_type` value that unlocks business pricing.
 const COMPANY: &str = "company";
 
-/// The resolved price for one product and one viewer.
+/// The resolved price for one product and one viewer (the slim shape templates
+/// and the cart use).
 #[derive(Debug, Clone, Copy)]
 pub struct PricedProduct {
     /// What the viewer pays, in minor units.
@@ -34,26 +41,57 @@ impl PricedProduct {
     }
 }
 
-/// Is this viewer a business (company) account?
-fn is_company(user: Option<&users::Model>) -> bool {
-    matches!(user, Some(u) if u.account_type == COMPANY)
+/// Full breakdown for one product and one viewer, used by the admin company page
+/// (which needs to show each layer and any collision). The storefront only needs
+/// [`PriceDetail::priced`].
+#[derive(Debug, Clone)]
+pub struct PriceDetail {
+    pub regular_cents: i64,
+    pub public_cents: i64,
+    pub manual_cents: Option<i64>,
+    pub auto_cents: Option<i64>,
+    /// The profile that produced `auto_cents` (the resolved/only/biggest one).
+    pub auto_profile_id: Option<i32>,
+    /// Every assigned profile that covers this product.
+    pub covering_profile_ids: Vec<i32>,
+    /// True when more than one profile covers the product and the admin has not
+    /// resolved which wins (a fallback was used).
+    pub collision: bool,
+    pub price_cents: i64,
+    pub is_business: bool,
 }
 
-/// The public (non-business) price for a product.
-fn public_priced(product: &products::Model) -> PricedProduct {
-    PricedProduct {
-        price_cents: product.effective_price_cents(),
-        regular_cents: product.price_cents,
-        is_business: false,
+impl PriceDetail {
+    fn public_only(regular_cents: i64, public_cents: i64) -> Self {
+        Self {
+            regular_cents,
+            public_cents,
+            manual_cents: None,
+            auto_cents: None,
+            auto_profile_id: None,
+            covering_profile_ids: Vec::new(),
+            collision: false,
+            price_cents: public_cents,
+            is_business: false,
+        }
+    }
+
+    #[must_use]
+    pub fn priced(&self) -> PricedProduct {
+        PricedProduct {
+            price_cents: self.price_cents,
+            regular_cents: self.regular_cents,
+            is_business: self.is_business,
+        }
     }
 }
 
-/// Combine the public price with the business layers (Phase 1: the manual
-/// negotiated price), lowest wins. Pure so it can be unit-tested in isolation.
-fn combine(regular_cents: i64, public_cents: i64, manual: Option<i64>) -> PricedProduct {
-    match manual {
-        Some(m) if m <= public_cents => PricedProduct {
-            price_cents: m,
+/// The "lowest wins" decision: pick the business price only when it is at or
+/// below the public price. Pure, so it is unit-tested directly.
+fn decide(regular_cents: i64, public_cents: i64, business: Option<i64>) -> PricedProduct {
+    match business {
+        Some(b) if b <= public_cents => PricedProduct {
+            price_cents: b,
             regular_cents,
             is_business: true,
         },
@@ -65,8 +103,141 @@ fn combine(regular_cents: i64, public_cents: i64, manual: Option<i64>) -> Priced
     }
 }
 
-fn resolve(product: &products::Model, manual: Option<i64>) -> PricedProduct {
-    combine(product.price_cents, product.effective_price_cents(), manual)
+/// Is this viewer a business (company) account?
+fn is_company(user: Option<&users::Model>) -> bool {
+    matches!(user, Some(u) if u.account_type == COMPANY)
+}
+
+/// Everything needed to resolve every product's business price for one account,
+/// loaded once so listing pages and the cart avoid N+1 queries.
+struct B2bContext {
+    manual: HashMap<i32, i64>,
+    profiles: Vec<discount_profiles::Model>,
+    membership: HashMap<i32, HashSet<i32>>,
+    resolutions: HashMap<i32, i32>,
+}
+
+async fn load_b2b(ctx: &AppContext, user_id: i32) -> Result<B2bContext> {
+    let manual = account_product_prices::Model::map_for_user(&ctx.db, user_id).await?;
+
+    let assigns = account_discount_profiles::Entity::find()
+        .filter(account_discount_profiles::Column::UserId.eq(user_id))
+        .all(&ctx.db)
+        .await?;
+    let profile_ids: Vec<i32> = assigns.iter().map(|a| a.discount_profile_id).collect();
+
+    let (profiles, membership) = if profile_ids.is_empty() {
+        (Vec::new(), HashMap::new())
+    } else {
+        let profiles = discount_profiles::Entity::find()
+            .filter(discount_profiles::Column::Id.is_in(profile_ids.clone()))
+            .all(&ctx.db)
+            .await?;
+        let rows = discount_profile_products::Entity::find()
+            .filter(discount_profile_products::Column::DiscountProfileId.is_in(profile_ids))
+            .all(&ctx.db)
+            .await?;
+        let mut membership: HashMap<i32, HashSet<i32>> = HashMap::new();
+        for row in rows {
+            membership
+                .entry(row.discount_profile_id)
+                .or_default()
+                .insert(row.product_id);
+        }
+        (profiles, membership)
+    };
+
+    let resolutions = account_product_resolutions::Entity::find()
+        .filter(account_product_resolutions::Column::UserId.eq(user_id))
+        .all(&ctx.db)
+        .await?
+        .into_iter()
+        .map(|r| (r.product_id, r.discount_profile_id))
+        .collect();
+
+    Ok(B2bContext {
+        manual,
+        profiles,
+        membership,
+        resolutions,
+    })
+}
+
+/// Resolve one product's full price breakdown for `b2b` (None = public viewer).
+fn detail_for(product: &products::Model, b2b: Option<&B2bContext>) -> PriceDetail {
+    let regular = product.price_cents;
+    let public = product.effective_price_cents();
+    let Some(b2b) = b2b else {
+        return PriceDetail::public_only(regular, public);
+    };
+
+    let manual = b2b.manual.get(&product.id).copied();
+
+    // Which assigned profiles cover this product.
+    let empty = HashSet::new();
+    let covering: Vec<&discount_profiles::Model> = b2b
+        .profiles
+        .iter()
+        .filter(|p| p.covers(product.id, b2b.membership.get(&p.id).unwrap_or(&empty)))
+        .collect();
+
+    let mut auto_cents = None;
+    let mut auto_profile_id = None;
+    let mut collision = false;
+    if !covering.is_empty() {
+        let chosen = if covering.len() == 1 {
+            covering[0]
+        } else {
+            // Two+ profiles collide: honour the admin's resolution, else fall
+            // back to the biggest discount and flag it for resolving.
+            match b2b
+                .resolutions
+                .get(&product.id)
+                .and_then(|rid| covering.iter().find(|p| p.id == *rid).copied())
+            {
+                Some(resolved) => resolved,
+                None => {
+                    collision = true;
+                    covering
+                        .iter()
+                        .max_by_key(|p| p.percent_bp)
+                        .copied()
+                        .expect("covering is non-empty")
+                }
+            }
+        };
+        auto_profile_id = Some(chosen.id);
+        auto_cents = Some(apply_discount_bp(regular, chosen.percent_bp));
+    }
+
+    let business = [manual, auto_cents].into_iter().flatten().min();
+    let priced = decide(regular, public, business);
+
+    PriceDetail {
+        regular_cents: regular,
+        public_cents: public,
+        manual_cents: manual,
+        auto_cents,
+        auto_profile_id,
+        covering_profile_ids: covering.iter().map(|p| p.id).collect(),
+        collision,
+        price_cents: priced.price_cents,
+        is_business: priced.is_business,
+    }
+}
+
+/// Full breakdowns for many products for `user`, batching per-account lookups.
+pub async fn detail_many(
+    ctx: &AppContext,
+    list: &[products::Model],
+    user: Option<&users::Model>,
+) -> Result<Vec<PriceDetail>> {
+    let b2b = if is_company(user) {
+        Some(load_b2b(ctx, user.expect("is_company implies Some").id).await?)
+    } else {
+        None
+    };
+    Ok(list.iter().map(|p| detail_for(p, b2b.as_ref())).collect())
 }
 
 /// Price one product for `user` (`None` = anonymous/public).
@@ -75,17 +246,8 @@ pub async fn price_for(
     product: &products::Model,
     user: Option<&users::Model>,
 ) -> Result<PricedProduct> {
-    if !is_company(user) {
-        return Ok(public_priced(product));
-    }
-    let user = user.expect("is_company implies Some");
-    let manual = account_product_prices::Entity::find()
-        .filter(account_product_prices::Column::UserId.eq(user.id))
-        .filter(account_product_prices::Column::ProductId.eq(product.id))
-        .one(&ctx.db)
-        .await?
-        .map(|row| row.price_cents);
-    Ok(resolve(product, manual))
+    let detail = detail_many(ctx, std::slice::from_ref(product), user).await?;
+    Ok(detail[0].priced())
 }
 
 /// Price many products for `user`, batching the per-account lookups to avoid
@@ -95,55 +257,53 @@ pub async fn price_many(
     list: &[products::Model],
     user: Option<&users::Model>,
 ) -> Result<Vec<PricedProduct>> {
-    if !is_company(user) {
-        return Ok(list.iter().map(public_priced).collect());
-    }
-    let user = user.expect("is_company implies Some");
-    let manual = account_product_prices::Model::map_for_user(&ctx.db, user.id).await?;
-    Ok(list
+    Ok(detail_many(ctx, list, user)
+        .await?
         .iter()
-        .map(|product| resolve(product, manual.get(&product.id).copied()))
+        .map(PriceDetail::priced)
         .collect())
 }
 
 #[cfg(test)]
 mod tests {
-    use super::combine;
+    use super::decide;
+    use crate::shared::money::apply_discount_bp;
 
-    // regular 100.00, no public sale, no negotiated price.
     #[test]
     fn public_only() {
-        let p = combine(10000, 10000, None);
+        let p = decide(10000, 10000, None);
         assert_eq!(p.price_cents, 10000);
         assert!(!p.is_reduced());
         assert!(!p.is_business);
     }
 
-    // A negotiated price below the public price wins and is flagged business.
     #[test]
-    fn negotiated_lower_wins() {
-        let p = combine(10000, 10000, Some(9000));
+    fn business_lower_wins() {
+        let p = decide(10000, 10000, Some(9000));
         assert_eq!(p.price_cents, 9000);
-        assert!(p.is_reduced());
         assert!(p.is_business);
     }
 
-    // A public sale below the negotiated price wins (lowest wins); not business.
     #[test]
-    fn public_sale_beats_negotiated() {
-        // regular 100, public sale 80, negotiated 90 -> pay 80.
-        let p = combine(10000, 8000, Some(9000));
+    fn public_sale_beats_business() {
+        // regular 100, public sale 80, business best 90 -> pay 80, not business.
+        let p = decide(10000, 8000, Some(9000));
         assert_eq!(p.price_cents, 8000);
-        assert!(p.is_reduced());
         assert!(!p.is_business);
     }
 
-    // A negotiated price equal to the public price is still treated as theirs.
     #[test]
-    fn negotiated_equal_is_business() {
-        let p = combine(10000, 10000, Some(10000));
+    fn business_equal_is_business() {
+        let p = decide(10000, 10000, Some(10000));
         assert_eq!(p.price_cents, 10000);
-        assert!(!p.is_reduced());
         assert!(p.is_business);
     }
+
+    #[test]
+    fn discount_bp_rounds_half_up() {
+        assert_eq!(apply_discount_bp(10000, 500), 9500); // 5%
+        assert_eq!(apply_discount_bp(10000, 1500), 8500); // 15%
+        assert_eq!(apply_discount_bp(999, 500), 949); // 49.95 -> 50 off
+        assert_eq!(apply_discount_bp(10000, 0), 10000);
+    }
 }