808 lines
25 KiB
Rust
808 lines
25 KiB
Rust
use std::collections::HashMap;
|
|
|
|
use crate::{
|
|
controllers::{
|
|
admin,
|
|
auth as auth_controller,
|
|
i18n::current_lang,
|
|
media::{detect_image_extension, store_upload, IMAGE_MAX_BYTES, IMAGE_STORAGE_DIR},
|
|
},
|
|
models::{
|
|
_entities::{categories, product_images, products},
|
|
users,
|
|
},
|
|
};
|
|
use axum::extract::{DefaultBodyLimit, Multipart};
|
|
use axum_extra::extract::cookie::CookieJar;
|
|
use loco_rs::prelude::*;
|
|
use sea_orm::{
|
|
ActiveModelTrait, ColumnTrait, EntityTrait, ModelTrait, PaginatorTrait, QueryFilter,
|
|
QueryOrder, QuerySelect, Set,
|
|
};
|
|
use serde_json::json;
|
|
|
|
// ---------------------------------------------------------------------------
|
|
// Shared helpers
|
|
// ---------------------------------------------------------------------------
|
|
|
|
fn slugify(value: &str) -> String {
|
|
let mut slug = String::new();
|
|
let mut last_was_dash = false;
|
|
for ch in value.chars().flat_map(char::to_lowercase) {
|
|
if ch.is_ascii_alphanumeric() {
|
|
slug.push(ch);
|
|
last_was_dash = false;
|
|
} else if !last_was_dash && !slug.is_empty() {
|
|
slug.push('-');
|
|
last_was_dash = true;
|
|
}
|
|
}
|
|
slug.trim_matches('-').to_string()
|
|
}
|
|
|
|
fn normalize_empty(value: Option<String>) -> Option<String> {
|
|
value.and_then(|value| {
|
|
let value = value.trim().to_string();
|
|
if value.is_empty() {
|
|
None
|
|
} else {
|
|
Some(value)
|
|
}
|
|
})
|
|
}
|
|
|
|
/// Parse a price typed in major units ("12", "12.5", "12.34") into integer
|
|
/// minor units (cents). Rejects negatives and more than two decimals.
|
|
fn parse_price_to_cents(value: &str) -> Result<i64> {
|
|
let value = value.trim().replace(',', ".");
|
|
let invalid = || Error::BadRequest("invalid price".to_string());
|
|
let (whole, frac) = match value.split_once('.') {
|
|
Some((w, f)) => (w, f),
|
|
None => (value.as_str(), ""),
|
|
};
|
|
if frac.len() > 2 || !whole.chars().all(|c| c.is_ascii_digit()) || whole.is_empty() {
|
|
return Err(invalid());
|
|
}
|
|
if !frac.chars().all(|c| c.is_ascii_digit()) {
|
|
return Err(invalid());
|
|
}
|
|
let whole: i64 = whole.parse().map_err(|_| invalid())?;
|
|
let cents: i64 = match frac.len() {
|
|
0 => 0,
|
|
1 => frac.parse::<i64>().map_err(|_| invalid())? * 10,
|
|
_ => frac.parse().map_err(|_| invalid())?,
|
|
};
|
|
Ok(whole * 100 + cents)
|
|
}
|
|
|
|
/// Render minor units as a human price string, e.g. `1234` -> `"12.34"`.
|
|
pub(crate) fn format_price(cents: i64) -> String {
|
|
format!("{}.{:02}", cents / 100, (cents % 100).abs())
|
|
}
|
|
|
|
async fn logged_in_admin(ctx: &AppContext, jar: &CookieJar) -> bool {
|
|
let Some(cookie) = jar.get(auth_controller::AUTH_COOKIE) else {
|
|
return false;
|
|
};
|
|
let Ok(jwt_config) = ctx.config.get_jwt_config() else {
|
|
return false;
|
|
};
|
|
let Ok(claims) = loco_rs::auth::jwt::JWT::new(&jwt_config.secret).validate(cookie.value())
|
|
else {
|
|
return false;
|
|
};
|
|
let Ok(user) = users::Model::find_by_pid(&ctx.db, &claims.claims.pid).await else {
|
|
return false;
|
|
};
|
|
admin::is_admin(ctx, &user)
|
|
}
|
|
|
|
async fn unique_slug<F, Fut>(base: &str, mut exists: F) -> Result<String>
|
|
where
|
|
F: FnMut(String) -> Fut,
|
|
Fut: std::future::Future<Output = Result<bool>>,
|
|
{
|
|
let base = if base.is_empty() {
|
|
"item".to_string()
|
|
} else {
|
|
base.to_string()
|
|
};
|
|
let mut slug = base.clone();
|
|
let mut suffix = 2;
|
|
while exists(slug.clone()).await? {
|
|
slug = format!("{base}-{suffix}");
|
|
suffix += 1;
|
|
}
|
|
Ok(slug)
|
|
}
|
|
|
|
/// Collected multipart form: text fields keyed by name, plus the raw bytes of
|
|
/// an `image` file part if one was uploaded (an empty file input is ignored).
|
|
struct MultipartForm {
|
|
fields: HashMap<String, String>,
|
|
image: Option<Vec<u8>>,
|
|
}
|
|
|
|
impl MultipartForm {
|
|
fn text(&self, key: &str) -> Option<String> {
|
|
normalize_empty(self.fields.get(key).cloned())
|
|
}
|
|
|
|
fn checked(&self, key: &str) -> bool {
|
|
matches!(self.fields.get(key).map(String::as_str), Some("on" | "true" | "1"))
|
|
}
|
|
}
|
|
|
|
async fn read_multipart_form(mut multipart: Multipart) -> Result<MultipartForm> {
|
|
let mut fields = HashMap::new();
|
|
let mut image = None;
|
|
|
|
while let Some(mut field) = multipart
|
|
.next_field()
|
|
.await
|
|
.map_err(|err| Error::BadRequest(format!("invalid multipart data: {err}")))?
|
|
{
|
|
let name = field.name().unwrap_or("").to_string();
|
|
if name == "image" {
|
|
let mut data = Vec::new();
|
|
while let Some(chunk) = field
|
|
.chunk()
|
|
.await
|
|
.map_err(|err| Error::BadRequest(format!("invalid multipart chunk: {err}")))?
|
|
{
|
|
data.extend_from_slice(&chunk);
|
|
if data.len() > IMAGE_MAX_BYTES {
|
|
return Err(Error::BadRequest(format!(
|
|
"image is larger than {} MB",
|
|
IMAGE_MAX_BYTES / 1024 / 1024
|
|
)));
|
|
}
|
|
}
|
|
if !data.is_empty() {
|
|
image = Some(data);
|
|
}
|
|
} else {
|
|
let value = field
|
|
.text()
|
|
.await
|
|
.map_err(|err| Error::BadRequest(format!("invalid multipart field: {err}")))?;
|
|
fields.insert(name, value);
|
|
}
|
|
}
|
|
|
|
Ok(MultipartForm { fields, image })
|
|
}
|
|
|
|
async fn store_image(ctx: &AppContext, data: Vec<u8>) -> Result<String> {
|
|
let extension = detect_image_extension(&data)?;
|
|
store_upload(ctx, IMAGE_STORAGE_DIR, extension, data).await
|
|
}
|
|
|
|
async fn category_by_id(ctx: &AppContext, id: i32) -> Result<categories::Model> {
|
|
categories::Entity::find_by_id(id)
|
|
.one(&ctx.db)
|
|
.await?
|
|
.ok_or_else(|| Error::NotFound)
|
|
}
|
|
|
|
async fn product_by_id(ctx: &AppContext, id: i32) -> Result<products::Model> {
|
|
products::Entity::find_by_id(id)
|
|
.one(&ctx.db)
|
|
.await?
|
|
.ok_or_else(|| Error::NotFound)
|
|
}
|
|
|
|
async fn first_image(ctx: &AppContext, product_id: i32) -> Result<Option<String>> {
|
|
Ok(product_images::Entity::find()
|
|
.filter(product_images::Column::ProductId.eq(product_id))
|
|
.order_by_asc(product_images::Column::Position)
|
|
.one(&ctx.db)
|
|
.await?
|
|
.map(|image| image.image_id))
|
|
}
|
|
|
|
/// Shape a product for templates: the model fields plus a formatted price,
|
|
/// its (optional) primary image filename and category name.
|
|
fn product_json(
|
|
product: &products::Model,
|
|
image: Option<String>,
|
|
category_name: Option<String>,
|
|
) -> serde_json::Value {
|
|
json!({
|
|
"id": product.id,
|
|
"name": product.name,
|
|
"slug": product.slug,
|
|
"description": product.description,
|
|
"price": format_price(product.price_cents),
|
|
"currency": product.currency,
|
|
"sku": product.sku,
|
|
"stock": product.stock,
|
|
"published": product.published,
|
|
"image": image,
|
|
"category_name": category_name,
|
|
})
|
|
}
|
|
|
|
/// Latest published products (with primary image), shaped for templates.
|
|
/// Reused by the home page landing grid.
|
|
pub(crate) async fn featured_products(
|
|
ctx: &AppContext,
|
|
limit: u64,
|
|
) -> Result<Vec<serde_json::Value>> {
|
|
let list = products::Entity::find()
|
|
.filter(products::Column::Published.eq(true))
|
|
.order_by_desc(products::Column::PublishedAt)
|
|
.limit(limit)
|
|
.all(&ctx.db)
|
|
.await?;
|
|
let mut rows = Vec::new();
|
|
for product in list {
|
|
let image = first_image(ctx, product.id).await?;
|
|
rows.push(product_json(&product, image, None));
|
|
}
|
|
Ok(rows)
|
|
}
|
|
|
|
// ---------------------------------------------------------------------------
|
|
// Admin: products
|
|
// ---------------------------------------------------------------------------
|
|
|
|
#[debug_handler]
|
|
async fn admin_products(
|
|
auth: auth::JWT,
|
|
jar: CookieJar,
|
|
ViewEngine(v): ViewEngine<TeraView>,
|
|
State(ctx): State<AppContext>,
|
|
) -> Result<Response> {
|
|
admin::current_admin(auth, &ctx).await?;
|
|
let list = products::Entity::find()
|
|
.order_by_desc(products::Column::CreatedAt)
|
|
.all(&ctx.db)
|
|
.await?;
|
|
let mut rows = Vec::new();
|
|
for product in list {
|
|
let image = first_image(&ctx, product.id).await?;
|
|
let category_name = match product.category_id {
|
|
Some(id) => category_by_id(&ctx, id).await.ok().map(|c| c.name),
|
|
None => None,
|
|
};
|
|
rows.push(product_json(&product, image, category_name));
|
|
}
|
|
format::view(
|
|
&v,
|
|
"admin/catalog/products.html",
|
|
json!({ "products": rows, "lang": current_lang(&jar) }),
|
|
)
|
|
}
|
|
|
|
async fn product_form_context(ctx: &AppContext, jar: &CookieJar) -> Result<serde_json::Value> {
|
|
let categories = categories::Entity::find()
|
|
.order_by_asc(categories::Column::Position)
|
|
.order_by_asc(categories::Column::Name)
|
|
.all(&ctx.db)
|
|
.await?;
|
|
Ok(json!({ "categories": categories, "lang": current_lang(jar) }))
|
|
}
|
|
|
|
#[debug_handler]
|
|
async fn admin_product_new(
|
|
auth: auth::JWT,
|
|
jar: CookieJar,
|
|
ViewEngine(v): ViewEngine<TeraView>,
|
|
State(ctx): State<AppContext>,
|
|
) -> Result<Response> {
|
|
admin::current_admin(auth, &ctx).await?;
|
|
let mut context = product_form_context(&ctx, &jar).await?;
|
|
context["product"] = serde_json::Value::Null;
|
|
format::view(&v, "admin/catalog/product_form.html", context)
|
|
}
|
|
|
|
async fn parse_product_fields(
|
|
ctx: &AppContext,
|
|
form: &MultipartForm,
|
|
current_id: Option<i32>,
|
|
) -> Result<(String, String, Option<String>, i64, String, Option<String>, i32, Option<i32>, bool)> {
|
|
let name = form
|
|
.text("name")
|
|
.ok_or_else(|| Error::BadRequest("product name is required".to_string()))?;
|
|
let price_cents = parse_price_to_cents(
|
|
form.text("price")
|
|
.ok_or_else(|| Error::BadRequest("price is required".to_string()))?
|
|
.as_str(),
|
|
)?;
|
|
let currency = form.text("currency").unwrap_or_else(|| "EUR".to_string());
|
|
let description = form.text("description");
|
|
let sku = form.text("sku");
|
|
let stock = form
|
|
.text("stock")
|
|
.and_then(|s| s.parse::<i32>().ok())
|
|
.filter(|n| *n >= 0)
|
|
.unwrap_or(0);
|
|
let category_id = form.text("category_id").and_then(|s| s.parse::<i32>().ok());
|
|
let published = form.checked("published");
|
|
|
|
let desired = form
|
|
.text("slug")
|
|
.map(|s| slugify(&s))
|
|
.filter(|s| !s.is_empty())
|
|
.unwrap_or_else(|| slugify(&name));
|
|
let slug = unique_slug(&desired, |candidate| {
|
|
let ctx = ctx.clone();
|
|
async move {
|
|
let mut query =
|
|
products::Entity::find().filter(products::Column::Slug.eq(candidate));
|
|
if let Some(id) = current_id {
|
|
query = query.filter(products::Column::Id.ne(id));
|
|
}
|
|
Ok(query.count(&ctx.db).await? > 0)
|
|
}
|
|
})
|
|
.await?;
|
|
|
|
Ok((
|
|
name, slug, description, price_cents, currency, sku, stock, category_id, published,
|
|
))
|
|
}
|
|
|
|
#[debug_handler]
|
|
async fn admin_product_create(
|
|
auth: auth::JWT,
|
|
State(ctx): State<AppContext>,
|
|
multipart: Multipart,
|
|
) -> Result<Response> {
|
|
admin::current_admin(auth, &ctx).await?;
|
|
let form = read_multipart_form(multipart).await?;
|
|
let (name, slug, description, price_cents, currency, sku, stock, category_id, published) =
|
|
parse_product_fields(&ctx, &form, None).await?;
|
|
|
|
let product = products::ActiveModel {
|
|
name: Set(name),
|
|
slug: Set(slug),
|
|
description: Set(description),
|
|
price_cents: Set(price_cents),
|
|
currency: Set(currency),
|
|
sku: Set(sku),
|
|
stock: Set(stock),
|
|
view_count: Set(0),
|
|
published: Set(published),
|
|
published_at: Set(published.then(|| chrono::Utc::now().into())),
|
|
category_id: Set(category_id),
|
|
..Default::default()
|
|
}
|
|
.insert(&ctx.db)
|
|
.await?;
|
|
|
|
if let Some(data) = form.image {
|
|
let filename = store_image(&ctx, data).await?;
|
|
product_images::ActiveModel {
|
|
product_id: Set(product.id),
|
|
image_id: Set(filename),
|
|
position: Set(0),
|
|
alt: Set(None),
|
|
..Default::default()
|
|
}
|
|
.insert(&ctx.db)
|
|
.await?;
|
|
}
|
|
|
|
format::redirect("/admin/catalog/products")
|
|
}
|
|
|
|
#[debug_handler]
|
|
async fn admin_product_edit(
|
|
auth: auth::JWT,
|
|
jar: CookieJar,
|
|
ViewEngine(v): ViewEngine<TeraView>,
|
|
Path(id): Path<i32>,
|
|
State(ctx): State<AppContext>,
|
|
) -> Result<Response> {
|
|
admin::current_admin(auth, &ctx).await?;
|
|
let product = product_by_id(&ctx, id).await?;
|
|
let image = first_image(&ctx, id).await?;
|
|
let mut context = product_form_context(&ctx, &jar).await?;
|
|
context["product"] = json!({
|
|
"id": product.id,
|
|
"name": product.name,
|
|
"slug": product.slug,
|
|
"description": product.description,
|
|
"price": format_price(product.price_cents),
|
|
"currency": product.currency,
|
|
"sku": product.sku,
|
|
"stock": product.stock,
|
|
"published": product.published,
|
|
"category_id": product.category_id,
|
|
"image": image,
|
|
});
|
|
format::view(&v, "admin/catalog/product_form.html", context)
|
|
}
|
|
|
|
#[debug_handler]
|
|
async fn admin_product_update(
|
|
auth: auth::JWT,
|
|
Path(id): Path<i32>,
|
|
State(ctx): State<AppContext>,
|
|
multipart: Multipart,
|
|
) -> Result<Response> {
|
|
admin::current_admin(auth, &ctx).await?;
|
|
let existing = product_by_id(&ctx, id).await?;
|
|
let was_published = existing.published;
|
|
let form = read_multipart_form(multipart).await?;
|
|
let (name, slug, description, price_cents, currency, sku, stock, category_id, published) =
|
|
parse_product_fields(&ctx, &form, Some(id)).await?;
|
|
|
|
let mut product = existing.into_active_model();
|
|
product.name = Set(name);
|
|
product.slug = Set(slug);
|
|
product.description = Set(description);
|
|
product.price_cents = Set(price_cents);
|
|
product.currency = Set(currency);
|
|
product.sku = Set(sku);
|
|
product.stock = Set(stock);
|
|
product.category_id = Set(category_id);
|
|
product.published = Set(published);
|
|
if published && !was_published {
|
|
product.published_at = Set(Some(chrono::Utc::now().into()));
|
|
} else if !published {
|
|
product.published_at = Set(None);
|
|
}
|
|
product.update(&ctx.db).await?;
|
|
|
|
if let Some(data) = form.image {
|
|
let filename = store_image(&ctx, data).await?;
|
|
let next_position = product_images::Entity::find()
|
|
.filter(product_images::Column::ProductId.eq(id))
|
|
.count(&ctx.db)
|
|
.await? as i32;
|
|
product_images::ActiveModel {
|
|
product_id: Set(id),
|
|
image_id: Set(filename),
|
|
position: Set(next_position),
|
|
alt: Set(None),
|
|
..Default::default()
|
|
}
|
|
.insert(&ctx.db)
|
|
.await?;
|
|
}
|
|
|
|
format::redirect("/admin/catalog/products")
|
|
}
|
|
|
|
#[debug_handler]
|
|
async fn admin_product_delete(
|
|
auth: auth::JWT,
|
|
Path(id): Path<i32>,
|
|
State(ctx): State<AppContext>,
|
|
) -> Result<Response> {
|
|
admin::current_admin(auth, &ctx).await?;
|
|
product_by_id(&ctx, id).await?.delete(&ctx.db).await?;
|
|
format::redirect("/admin/catalog/products")
|
|
}
|
|
|
|
// ---------------------------------------------------------------------------
|
|
// Admin: categories
|
|
// ---------------------------------------------------------------------------
|
|
|
|
#[debug_handler]
|
|
async fn admin_categories(
|
|
auth: auth::JWT,
|
|
jar: CookieJar,
|
|
ViewEngine(v): ViewEngine<TeraView>,
|
|
State(ctx): State<AppContext>,
|
|
) -> Result<Response> {
|
|
admin::current_admin(auth, &ctx).await?;
|
|
let list = categories::Entity::find()
|
|
.order_by_asc(categories::Column::Position)
|
|
.order_by_asc(categories::Column::Name)
|
|
.all(&ctx.db)
|
|
.await?;
|
|
let mut rows = Vec::new();
|
|
for category in list {
|
|
let product_count = products::Entity::find()
|
|
.filter(products::Column::CategoryId.eq(category.id))
|
|
.count(&ctx.db)
|
|
.await?;
|
|
rows.push(json!({ "category": category, "product_count": product_count }));
|
|
}
|
|
format::view(
|
|
&v,
|
|
"admin/catalog/categories.html",
|
|
json!({ "categories": rows, "lang": current_lang(&jar) }),
|
|
)
|
|
}
|
|
|
|
#[debug_handler]
|
|
async fn admin_category_new(
|
|
auth: auth::JWT,
|
|
jar: CookieJar,
|
|
ViewEngine(v): ViewEngine<TeraView>,
|
|
State(ctx): State<AppContext>,
|
|
) -> Result<Response> {
|
|
admin::current_admin(auth, &ctx).await?;
|
|
format::view(
|
|
&v,
|
|
"admin/catalog/category_form.html",
|
|
json!({ "category": serde_json::Value::Null, "lang": current_lang(&jar) }),
|
|
)
|
|
}
|
|
|
|
async fn parse_category_fields(
|
|
ctx: &AppContext,
|
|
form: &MultipartForm,
|
|
current_id: Option<i32>,
|
|
) -> Result<(String, String, Option<String>, i32, bool)> {
|
|
let name = form
|
|
.text("name")
|
|
.ok_or_else(|| Error::BadRequest("category name is required".to_string()))?;
|
|
let description = form.text("description");
|
|
let position = form
|
|
.text("position")
|
|
.and_then(|s| s.parse::<i32>().ok())
|
|
.unwrap_or(0);
|
|
let published = form.checked("published");
|
|
|
|
let desired = form
|
|
.text("slug")
|
|
.map(|s| slugify(&s))
|
|
.filter(|s| !s.is_empty())
|
|
.unwrap_or_else(|| slugify(&name));
|
|
let slug = unique_slug(&desired, |candidate| {
|
|
let ctx = ctx.clone();
|
|
async move {
|
|
let mut query =
|
|
categories::Entity::find().filter(categories::Column::Slug.eq(candidate));
|
|
if let Some(id) = current_id {
|
|
query = query.filter(categories::Column::Id.ne(id));
|
|
}
|
|
Ok(query.count(&ctx.db).await? > 0)
|
|
}
|
|
})
|
|
.await?;
|
|
|
|
Ok((name, slug, description, position, published))
|
|
}
|
|
|
|
#[debug_handler]
|
|
async fn admin_category_create(
|
|
auth: auth::JWT,
|
|
State(ctx): State<AppContext>,
|
|
multipart: Multipart,
|
|
) -> Result<Response> {
|
|
admin::current_admin(auth, &ctx).await?;
|
|
let form = read_multipart_form(multipart).await?;
|
|
let (name, slug, description, position, published) =
|
|
parse_category_fields(&ctx, &form, None).await?;
|
|
let image_id = match form.image {
|
|
Some(data) => Some(store_image(&ctx, data).await?),
|
|
None => None,
|
|
};
|
|
|
|
categories::ActiveModel {
|
|
name: Set(name),
|
|
slug: Set(slug),
|
|
description: Set(description),
|
|
image_id: Set(image_id),
|
|
position: Set(position),
|
|
published: Set(published),
|
|
..Default::default()
|
|
}
|
|
.insert(&ctx.db)
|
|
.await?;
|
|
|
|
format::redirect("/admin/catalog/categories")
|
|
}
|
|
|
|
#[debug_handler]
|
|
async fn admin_category_edit(
|
|
auth: auth::JWT,
|
|
jar: CookieJar,
|
|
ViewEngine(v): ViewEngine<TeraView>,
|
|
Path(id): Path<i32>,
|
|
State(ctx): State<AppContext>,
|
|
) -> Result<Response> {
|
|
admin::current_admin(auth, &ctx).await?;
|
|
format::view(
|
|
&v,
|
|
"admin/catalog/category_form.html",
|
|
json!({ "category": category_by_id(&ctx, id).await?, "lang": current_lang(&jar) }),
|
|
)
|
|
}
|
|
|
|
#[debug_handler]
|
|
async fn admin_category_update(
|
|
auth: auth::JWT,
|
|
Path(id): Path<i32>,
|
|
State(ctx): State<AppContext>,
|
|
multipart: Multipart,
|
|
) -> Result<Response> {
|
|
admin::current_admin(auth, &ctx).await?;
|
|
let existing = category_by_id(&ctx, id).await?;
|
|
let form = read_multipart_form(multipart).await?;
|
|
let (name, slug, description, position, published) =
|
|
parse_category_fields(&ctx, &form, Some(id)).await?;
|
|
|
|
let mut category = existing.into_active_model();
|
|
category.name = Set(name);
|
|
category.slug = Set(slug);
|
|
category.description = Set(description);
|
|
category.position = Set(position);
|
|
category.published = Set(published);
|
|
if let Some(data) = form.image {
|
|
category.image_id = Set(Some(store_image(&ctx, data).await?));
|
|
}
|
|
category.update(&ctx.db).await?;
|
|
|
|
format::redirect("/admin/catalog/categories")
|
|
}
|
|
|
|
#[debug_handler]
|
|
async fn admin_category_delete(
|
|
auth: auth::JWT,
|
|
Path(id): Path<i32>,
|
|
State(ctx): State<AppContext>,
|
|
) -> Result<Response> {
|
|
admin::current_admin(auth, &ctx).await?;
|
|
category_by_id(&ctx, id).await?.delete(&ctx.db).await?;
|
|
format::redirect("/admin/catalog/categories")
|
|
}
|
|
|
|
// ---------------------------------------------------------------------------
|
|
// Public storefront
|
|
// ---------------------------------------------------------------------------
|
|
|
|
#[debug_handler]
|
|
async fn shop_index(
|
|
jar: CookieJar,
|
|
ViewEngine(v): ViewEngine<TeraView>,
|
|
State(ctx): State<AppContext>,
|
|
) -> Result<Response> {
|
|
let list = products::Entity::find()
|
|
.filter(products::Column::Published.eq(true))
|
|
.order_by_desc(products::Column::PublishedAt)
|
|
.all(&ctx.db)
|
|
.await?;
|
|
let mut rows = Vec::new();
|
|
for product in list {
|
|
let image = first_image(&ctx, product.id).await?;
|
|
rows.push(product_json(&product, image, None));
|
|
}
|
|
let categories = categories::Entity::find()
|
|
.filter(categories::Column::Published.eq(true))
|
|
.order_by_asc(categories::Column::Position)
|
|
.all(&ctx.db)
|
|
.await?;
|
|
|
|
format::view(
|
|
&v,
|
|
"shop/index.html",
|
|
json!({
|
|
"products": rows,
|
|
"categories": categories,
|
|
"logged_in_admin": logged_in_admin(&ctx, &jar).await,
|
|
"lang": current_lang(&jar),
|
|
}),
|
|
)
|
|
}
|
|
|
|
#[debug_handler]
|
|
async fn shop_show(
|
|
jar: CookieJar,
|
|
ViewEngine(v): ViewEngine<TeraView>,
|
|
Path(slug): Path<String>,
|
|
State(ctx): State<AppContext>,
|
|
) -> Result<Response> {
|
|
let product = products::Entity::find()
|
|
.filter(products::Column::Slug.eq(slug))
|
|
.filter(products::Column::Published.eq(true))
|
|
.one(&ctx.db)
|
|
.await?
|
|
.ok_or_else(|| Error::NotFound)?;
|
|
|
|
let mut active = product.clone().into_active_model();
|
|
active.view_count = Set(product.view_count + 1);
|
|
let product = active.update(&ctx.db).await?;
|
|
|
|
let images = product_images::Entity::find()
|
|
.filter(product_images::Column::ProductId.eq(product.id))
|
|
.order_by_asc(product_images::Column::Position)
|
|
.all(&ctx.db)
|
|
.await?;
|
|
let category = match product.category_id {
|
|
Some(id) => category_by_id(&ctx, id).await.ok(),
|
|
None => None,
|
|
};
|
|
|
|
format::view(
|
|
&v,
|
|
"shop/show.html",
|
|
json!({
|
|
"product": product_json(&product, None, category.as_ref().map(|c| c.name.clone())),
|
|
"images": images.iter().map(|i| i.image_id.clone()).collect::<Vec<_>>(),
|
|
"category": category,
|
|
"logged_in_admin": logged_in_admin(&ctx, &jar).await,
|
|
"lang": current_lang(&jar),
|
|
}),
|
|
)
|
|
}
|
|
|
|
#[debug_handler]
|
|
async fn shop_category(
|
|
jar: CookieJar,
|
|
ViewEngine(v): ViewEngine<TeraView>,
|
|
Path(slug): Path<String>,
|
|
State(ctx): State<AppContext>,
|
|
) -> Result<Response> {
|
|
let category = categories::Entity::find()
|
|
.filter(categories::Column::Slug.eq(slug))
|
|
.filter(categories::Column::Published.eq(true))
|
|
.one(&ctx.db)
|
|
.await?
|
|
.ok_or_else(|| Error::NotFound)?;
|
|
|
|
let list = products::Entity::find()
|
|
.filter(products::Column::CategoryId.eq(category.id))
|
|
.filter(products::Column::Published.eq(true))
|
|
.order_by_desc(products::Column::PublishedAt)
|
|
.all(&ctx.db)
|
|
.await?;
|
|
let mut rows = Vec::new();
|
|
for product in list {
|
|
let image = first_image(&ctx, product.id).await?;
|
|
rows.push(product_json(&product, image, None));
|
|
}
|
|
|
|
format::view(
|
|
&v,
|
|
"shop/category.html",
|
|
json!({
|
|
"category": category,
|
|
"products": rows,
|
|
"logged_in_admin": logged_in_admin(&ctx, &jar).await,
|
|
"lang": current_lang(&jar),
|
|
}),
|
|
)
|
|
}
|
|
|
|
pub fn routes() -> Routes {
|
|
let image_limit = DefaultBodyLimit::max(IMAGE_MAX_BYTES + 1024 * 1024);
|
|
Routes::new()
|
|
// public storefront
|
|
.add("/shop", get(shop_index))
|
|
.add("/shop/{slug}", get(shop_show))
|
|
.add("/category/{slug}", get(shop_category))
|
|
// admin products
|
|
.add("/admin/catalog/products", get(admin_products))
|
|
.add("/admin/catalog/products/new", get(admin_product_new))
|
|
.add(
|
|
"/admin/catalog/products",
|
|
post(admin_product_create).layer(image_limit.clone()),
|
|
)
|
|
.add("/admin/catalog/products/{id}/edit", get(admin_product_edit))
|
|
.add(
|
|
"/admin/catalog/products/{id}",
|
|
post(admin_product_update).layer(image_limit.clone()),
|
|
)
|
|
.add(
|
|
"/admin/catalog/products/{id}/delete",
|
|
post(admin_product_delete),
|
|
)
|
|
// admin categories
|
|
.add("/admin/catalog/categories", get(admin_categories))
|
|
.add("/admin/catalog/categories/new", get(admin_category_new))
|
|
.add(
|
|
"/admin/catalog/categories",
|
|
post(admin_category_create).layer(image_limit.clone()),
|
|
)
|
|
.add(
|
|
"/admin/catalog/categories/{id}/edit",
|
|
get(admin_category_edit),
|
|
)
|
|
.add(
|
|
"/admin/catalog/categories/{id}",
|
|
post(admin_category_update).layer(image_limit),
|
|
)
|
|
.add(
|
|
"/admin/catalog/categories/{id}/delete",
|
|
post(admin_category_delete),
|
|
)
|
|
}
|