bazzar/crates/model/src/lib.rs

#![feature(drain_filter)]

pub mod api;

pub mod encrypt;
pub mod v3;

use std::fmt::{Display, Formatter};
use std::ops;
use std::ops::{BitOr, Range};
use std::str::FromStr;

use derive_more::{Deref, DerefMut, Display, From};
use serde::de::{Error, Visitor};
use serde::{Deserialize, Deserializer, Serialize};

pub use crate::encrypt::*;
use crate::v2::ProductVariantId;

#[derive(Debug, Hash, thiserror::Error)]
pub enum TransformError {
    #[error("Given value is below minimal value")]
    BelowMinimal,
    #[error("Given value is not valid day flag")]
    NotDay,
    #[error("Given value is not valid email address")]
    NotEmail,
}

pub type RecordId = i32;

// macro_rules! category_svg {
//     ($name: expr) => {
//         concat!("/svg/", $name, ".svg")
//     };
// }

pub struct CategoryMapper;

impl CategoryMapper {
    pub fn db_into_api(
        name: ProductCategory,
        categories: &[crate::v2::Category],
    ) -> Option<crate::api::Category> {
        categories
            .iter()
            .find(|category| category.name.as_str() == name.as_str())
            .map(
                |crate::v2::Category {
                     id,
                     parent_id,
                     name,
                     key,
                     svg,
                 }| crate::api::Category {
                    id: id.clone(),
                    parent_id: parent_id.clone(),
                    name: name.clone(),
                    key: key.clone(),
                    svg: svg.clone(),
                },
            )
    }
}

#[cfg_attr(feature = "db", derive(sqlx::Type))]
#[cfg_attr(feature = "db", sqlx(rename_all = "snake_case"))]
#[derive(Copy, Clone, Debug, Hash, PartialEq, Eq, Default, Display, Deserialize, Serialize)]
#[serde(rename_all = "snake_case")]
pub enum OrderItemState {
    #[default]
    #[display(fmt = "Poprawny")]
    Valid,
    #[display(fmt = "Niedostępny")]
    OutOfStock,
}

#[cfg_attr(feature = "db", derive(sqlx::Type))]
#[cfg_attr(feature = "db", sqlx(rename_all = "snake_case"))]
#[derive(Copy, Clone, Debug, Hash, PartialEq, Eq, Display, Deserialize, Serialize)]
#[serde(rename_all = "snake_case")]
pub enum OrderStatus {
    #[display(fmt = "Potwierdzone")]
    Confirmed,
    #[display(fmt = "Odebrane")]
    Delivered,
    #[display(fmt = "Opłacone")]
    Payed,
    #[display(fmt = "Anulowane")]
    Cancelled,
    #[display(fmt = "Wymaga zwrotu płatności")]
    RequireRefund,
    #[display(fmt = "Płatność zwrócona")]
    Refunded,
}

#[cfg_attr(feature = "db", derive(sqlx::Type))]
#[cfg_attr(feature = "db", sqlx(rename_all = "snake_case"))]
#[derive(Copy, Clone, Debug, Hash, PartialEq, Eq, Display, Deserialize, Serialize)]
#[serde(rename_all = "snake_case")]
pub enum Role {
    #[display(fmt = "Adminitrator")]
    Admin,
    #[display(fmt = "Użytkownik")]
    User,
}

impl PartialEq<&str> for Role {
    fn eq(&self, other: &&str) -> bool {
        self.as_str() == *other
    }
}

impl Role {
    pub fn as_str(&self) -> &str {
        match self {
            Role::Admin => "Admin",
            Role::User => "User",
        }
    }
}

#[cfg_attr(feature = "db", derive(sqlx::Type))]
#[derive(Copy, Clone, Debug, PartialEq, Eq, Hash, Display, Deserialize, Serialize)]
#[serde(rename_all = "snake_case")]
pub enum QuantityUnit {
    #[cfg_attr(feature = "db", sqlx(rename = "g"))]
    Gram,
    #[cfg_attr(feature = "db", sqlx(rename = "dkg"))]
    Decagram,
    #[cfg_attr(feature = "db", sqlx(rename = "kg"))]
    Kilogram,
    #[cfg_attr(feature = "db", sqlx(rename = "piece"))]
    Piece,
}

impl QuantityUnit {
    pub fn name(self) -> &'static str {
        match self {
            Self::Gram => "Gram",
            Self::Decagram => "Decagram",
            Self::Kilogram => "Kilogram",
            Self::Piece => "Piece",
        }
    }

    pub fn short_name(&self) -> &'static str {
        match self {
            Self::Gram => "g",
            Self::Decagram => "dkg",
            Self::Kilogram => "kg",
            Self::Piece => "piece",
        }
    }
}

#[cfg_attr(feature = "db", derive(sqlx::Type))]
#[cfg_attr(feature = "db", sqlx(rename_all = "snake_case"))]
#[derive(Copy, Clone, Debug, Hash, PartialEq, Eq, Display, Deserialize, Serialize)]
#[serde(rename_all = "snake_case")]
pub enum PaymentMethod {
    PayU,
    PaymentOnTheSpot,
}

impl Default for PaymentMethod {
    fn default() -> Self {
        Self::PaymentOnTheSpot
    }
}

#[cfg_attr(feature = "db", derive(sqlx::Type))]
#[cfg_attr(feature = "db", sqlx(rename_all = "snake_case"))]
#[derive(Copy, Clone, Debug, Hash, PartialEq, Eq, Display, Deserialize, Serialize)]
#[serde(rename_all = "snake_case")]
pub enum ShoppingCartState {
    Active,
    Closed,
}

#[cfg_attr(feature = "db", derive(sqlx::Type))]
#[cfg_attr(feature = "db", sqlx(rename_all = "snake_case"))]
#[derive(Copy, Clone, Debug, Hash, Display, Deserialize, Serialize, PartialEq, Eq)]
#[serde(rename_all = "snake_case")]
pub enum Audience {
    Web,
    Mobile,
    Feed,
    AdminPanel,
}

impl PartialEq<&str> for Audience {
    fn eq(&self, other: &&str) -> bool {
        self.as_str() == *other
    }
}

impl Audience {
    pub fn as_str(&self) -> &str {
        match self {
            Audience::Web => "Web",
            Audience::Mobile => "Mobile",
            Audience::Feed => "Feed",
            Audience::AdminPanel => "AdminPanel",
        }
    }
}

#[cfg_attr(feature = "db", derive(sqlx::Type))]
#[cfg_attr(feature = "db", sqlx(rename_all = "snake_case"))]
#[derive(Copy, Clone, Debug, Display, Deserialize, Serialize, PartialEq, Eq)]
#[serde(rename_all = "snake_case")]
pub enum AccountState {
    Active,
    Suspended,
    Banned,
}

impl Default for Audience {
    fn default() -> Self {
        Self::Web
    }
}

#[cfg_attr(feature = "db", derive(sqlx::Type), sqlx(transparent))]
#[derive(
    Default,
    Debug,
    Copy,
    Clone,
    Hash,
    PartialOrd,
    PartialEq,
    Eq,
    Serialize,
    Deserialize,
    Deref,
    From,
)]
#[serde(transparent)]
pub struct Price(NonNegative);

impl Price {
    pub fn from_u32(price: u32) -> Self {
        Self(NonNegative(price as i32))
    }
}

impl ops::Mul<Quantity> for Price {
    type Output = Self;

    fn mul(self, rhs: Quantity) -> Self::Output {
        Self(NonNegative(rhs.0 .0 * self.0 .0))
    }
}

pub trait Ranged: Sized + From<u32> + Copy {
    fn in_range(self, range: Range<u32>) -> Self {
        let v = self.into_raw().try_into().unwrap_or(range.start);
        v.max(range.start).min(range.end).into()
    }

    fn into_raw(self) -> i32;
}

#[cfg_attr(feature = "db", derive(sqlx::Type), sqlx(transparent))]
#[derive(
    Debug, Copy, Clone, Hash, PartialOrd, PartialEq, Eq, Serialize, Deserialize, Deref, From,
)]
#[serde(transparent)]
pub struct Limit(NonNegative);

impl Default for Limit {
    fn default() -> Self {
        200.into()
    }
}

impl From<u32> for Limit {
    fn from(value: u32) -> Self {
        Self::from_u32(value)
    }
}

impl Ranged for Limit {
    fn into_raw(self) -> i32 {
        self.0 .0
    }
}

impl Limit {
    pub fn from_u32(price: u32) -> Self {
        Self(NonNegative(price as i32))
    }
}

#[cfg_attr(feature = "db", derive(sqlx::Type), sqlx(transparent))]
#[derive(
    Default,
    Debug,
    Copy,
    Clone,
    Hash,
    PartialOrd,
    PartialEq,
    Eq,
    Serialize,
    Deserialize,
    Deref,
    From,
)]
#[serde(transparent)]
pub struct Offset(NonNegative);

impl From<u32> for Offset {
    fn from(value: u32) -> Self {
        Self::from_u32(value)
    }
}

impl Ranged for Offset {
    fn into_raw(self) -> i32 {
        self.0 .0
    }
}

impl Offset {
    pub fn from_u32(price: u32) -> Self {
        Self(NonNegative(price as i32))
    }
}

#[cfg_attr(feature = "db", derive(sqlx::Type), sqlx(transparent))]
#[derive(Serialize, Deserialize, Default, Debug, PartialEq, Eq, Copy, Clone, Hash, Deref, From)]
#[serde(transparent)]
pub struct Quantity(NonNegative);

impl Quantity {
    pub fn from_u32(v: u32) -> Self {
        Self(NonNegative(v.try_into().unwrap_or_default()))
    }
}

impl ops::Add for Quantity {
    type Output = Self;

    fn add(self, rhs: Self) -> Self::Output {
        Self(self.0 + rhs.0)
    }
}

impl ops::Sub for Quantity {
    type Output = Self;

    fn sub(self, rhs: Self) -> Self::Output {
        Self(self.0 - rhs.0)
    }
}

impl TryFrom<i32> for Quantity {
    type Error = TransformError;

    fn try_from(value: i32) -> Result<Self, Self::Error> {
        Ok(Self(value.try_into()?))
    }
}

#[cfg_attr(feature = "db", derive(sqlx::Type), sqlx(transparent))]
#[derive(Deserialize, Serialize, Debug, Clone, PartialEq, Eq, Deref, From, Display)]
#[serde(transparent)]
pub struct Login(String);

impl Login {
    pub fn new<S: Into<String>>(s: S) -> Self {
        Self(s.into())
    }
}

#[cfg_attr(feature = "db", derive(sqlx::Type), sqlx(transparent))]
#[derive(
    Serialize, Debug, Clone, Default, PartialOrd, PartialEq, Eq, Deref, DerefMut, From, Display,
)]
#[serde(transparent)]
pub struct Email(String);

impl Email {
    pub fn invalid_empty() -> Self {
        Self("".into())
    }

    pub fn new<S: Into<String>>(s: S) -> Self {
        Self(s.into())
    }
}

#[cfg_attr(feature = "db", derive(sqlx::Type), sqlx(transparent))]
#[derive(
    Serialize,
    Deserialize,
    Debug,
    Clone,
    Default,
    PartialOrd,
    PartialEq,
    Eq,
    Deref,
    DerefMut,
    From,
    Display,
)]
#[serde(transparent)]
pub struct Phone(String);

impl Phone {
    pub fn invalid_empty() -> Self {
        Self("".into())
    }

    pub fn new<S: Into<String>>(s: S) -> Self {
        Self(s.into())
    }
}

impl FromStr for Email {
    type Err = TransformError;

    fn from_str(s: &str) -> Result<Self, Self::Err> {
        if validator::validate_email(s) {
            Ok(Self(String::from(s)))
        } else {
            Err(TransformError::NotEmail)
        }
    }
}

impl<'de> serde::Deserialize<'de> for Email {
    fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
    where
        D: Deserializer<'de>,
    {
        struct EmailVisitor {}
        impl<'v> Visitor<'v> for EmailVisitor {
            type Value = String;

            fn expecting(&self, formatter: &mut Formatter) -> std::fmt::Result {
                formatter.write_str("valid e-mail address")
            }

            fn visit_str<E>(self, s: &str) -> Result<Self::Value, E>
            where
                E: Error,
            {
                if validator::validate_email(s) {
                    Ok(String::from(s))
                } else {
                    Err(E::custom("this is not email address"))
                }
            }
        }

        Ok(Email(deserializer.deserialize_str(EmailVisitor {})?))
    }
}

#[cfg_attr(feature = "db", derive(sqlx::Type), sqlx(transparent))]
#[derive(
    Default, Debug, PartialEq, Eq, PartialOrd, Copy, Clone, Hash, Serialize, Deref, Display,
)]
#[serde(transparent)]
pub struct NonNegative(i32);

impl ops::Add for NonNegative {
    type Output = Self;

    fn add(self, rhs: Self) -> Self::Output {
        Self(self.0 + rhs.0)
    }
}

impl ops::Sub for NonNegative {
    type Output = Self;

    fn sub(self, rhs: Self) -> Self::Output {
        Self((self.0 - rhs.0).max(0))
    }
}

impl TryFrom<i32> for NonNegative {
    type Error = TransformError;

    fn try_from(value: i32) -> Result<Self, Self::Error> {
        if value < 0 {
            Err(TransformError::BelowMinimal)
        } else {
            Ok(Self(value))
        }
    }
}

impl<'de> serde::Deserialize<'de> for NonNegative {
    fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
    where
        D: Deserializer<'de>,
    {
        struct NonNegativeVisitor;
        impl<'v> Visitor<'v> for NonNegativeVisitor {
            type Value = i32;

            fn expecting(&self, formatter: &mut Formatter) -> std::fmt::Result {
                formatter.write_str("value equal or greater than 0")
            }

            fn visit_i32<E>(self, v: i32) -> Result<Self::Value, E>
            where
                E: Error,
            {
                if v >= 0 {
                    Ok(v)
                } else {
                    Err(E::custom("Value must be equal or greater than 0"))
                }
            }

            fn visit_i64<E>(self, v: i64) -> Result<Self::Value, E>
            where
                E: Error,
            {
                let v = v
                    .try_into()
                    .map_err(|_| E::custom("Value must be equal or greater than 0"))?;
                if v >= 0 {
                    Ok(v)
                } else {
                    Err(E::custom("Value must be equal or greater than 0"))
                }
            }

            fn visit_u32<E>(self, v: u32) -> Result<Self::Value, E>
            where
                E: Error,
            {
                let v = v
                    .try_into()
                    .map_err(|_| E::custom("Value must be equal or greater than 0"))?;
                Ok(v)
            }

            fn visit_u64<E>(self, v: u64) -> Result<Self::Value, E>
            where
                E: Error,
            {
                let v = v
                    .try_into()
                    .map_err(|_| E::custom("Value must be equal or greater than 0"))?;
                Ok(v)
            }
        }

        Ok(NonNegative(
            deserializer.deserialize_i32(NonNegativeVisitor)?,
        ))
    }
}

#[derive(
    Debug, Copy, Clone, Hash, PartialOrd, PartialEq, Eq, Serialize, Deserialize, Display, From,
)]
#[serde(rename_all = "lowercase")]
pub enum Day {
    Monday = 1,
    Tuesday = 1 << 1,
    Wednesday = 1 << 2,
    Thursday = 1 << 3,
    Friday = 1 << 4,
    Saturday = 1 << 5,
    Sunday = 1 << 6,
}

impl Day {
    pub fn name(&self) -> &str {
        match self {
            Self::Monday => "Monday",
            Self::Tuesday => "Tuesday",
            Self::Wednesday => "Wednesday",
            Self::Thursday => "Thursday",
            Self::Friday => "Friday",
            Self::Saturday => "Saturday",
            Self::Sunday => "Sunday",
        }
    }
    pub fn short_name(&self) -> &'static str {
        match self {
            Self::Monday => "Mon",
            Self::Tuesday => "Tue",
            Self::Wednesday => "Wed",
            Self::Thursday => "Thu",
            Self::Friday => "Fri",
            Self::Saturday => "Sat",
            Self::Sunday => "Sun",
        }
    }
}

impl BitOr for Day {
    type Output = Days;

    fn bitor(self, rhs: Self) -> Self::Output {
        Days(vec![self, rhs])
    }
}

impl TryFrom<i32> for Day {
    type Error = TransformError;

    fn try_from(value: i32) -> Result<Self, Self::Error> {
        if value == (Day::Monday as i32) {
            Ok(Day::Monday)
        } else if value == (Day::Tuesday as i32) {
            Ok(Day::Tuesday)
        } else if value == (Day::Wednesday as i32) {
            Ok(Day::Wednesday)
        } else if value == (Day::Thursday as i32) {
            Ok(Day::Thursday)
        } else if value == (Day::Friday as i32) {
            Ok(Day::Friday)
        } else if value == (Day::Saturday as i32) {
            Ok(Day::Saturday)
        } else if value == (Day::Sunday as i32) {
            Ok(Day::Sunday)
        } else {
            Err(TransformError::NotDay)
        }
    }
}

#[derive(Hash, Debug, PartialOrd, PartialEq, Eq, Serialize, Deserialize)]
#[serde(transparent)]
pub struct Days(pub Vec<Day>);

impl BitOr<Day> for Days {
    type Output = Self;

    fn bitor(mut self, rhs: Day) -> Self::Output {
        self.0.push(rhs);
        self
    }
}

impl ops::Deref for Days {
    type Target = Vec<Day>;

    fn deref(&self) -> &Self::Target {
        &self.0
    }
}

#[cfg(feature = "db")]
impl<'q> ::sqlx::encode::Encode<'q, sqlx::Postgres> for Days
where
    i32: ::sqlx::encode::Encode<'q, sqlx::Postgres>,
{
    fn encode_by_ref(
        &self,
        buf: &mut <sqlx::Postgres as ::sqlx::database::HasArguments<'q>>::ArgumentBuffer,
    ) -> ::sqlx::encode::IsNull {
        let value = self.0.iter().fold(0, |memo, v| memo | *v as i32);

        <i32 as ::sqlx::encode::Encode<sqlx::Postgres>>::encode_by_ref(&value, buf)
    }

    fn size_hint(&self) -> usize {
        <i32 as ::sqlx::encode::Encode<sqlx::Postgres>>::size_hint(&Default::default())
    }
}

#[cfg(feature = "db")]
impl<'r> ::sqlx::decode::Decode<'r, sqlx::Postgres> for Days
where
    i32: ::sqlx::decode::Decode<'r, sqlx::Postgres>,
{
    fn decode(
        value: <sqlx::Postgres as ::sqlx::database::HasValueRef<'r>>::ValueRef,
    ) -> Result<Self, Box<dyn ::std::error::Error + 'static + Send + Sync>> {
        let value = <i32 as ::sqlx::decode::Decode<'r, sqlx::Postgres>>::decode(value)?;
        Ok(Days(
            (0..7)
                .into_iter()
                .filter_map(|n| Day::try_from(value & 1 << n).ok())
                .collect(),
        ))
    }
}

#[cfg(feature = "db")]
impl sqlx::Type<sqlx::Postgres> for Days
where
    i32: ::sqlx::Type<sqlx::Postgres>,
{
    fn type_info() -> <sqlx::Postgres as ::sqlx::Database>::TypeInfo {
        <i32 as ::sqlx::Type<sqlx::Postgres>>::type_info()
    }

    fn compatible(ty: &<sqlx::Postgres as ::sqlx::Database>::TypeInfo) -> bool {
        <i32 as ::sqlx::Type<sqlx::Postgres>>::compatible(ty)
    }
}

#[cfg_attr(feature = "db", derive(sqlx::Type), sqlx(transparent))]
#[derive(Serialize, Deserialize, Debug, Deref, Display)]
#[serde(transparent)]
pub struct ResetToken(String);

impl ResetToken {
    pub fn new<S: Into<String>>(s: S) -> Self {
        Self(s.into())
    }
}

#[cfg_attr(feature = "db", derive(sqlx::Type), sqlx(transparent))]
#[derive(Serialize, Deserialize, Debug, Clone, Deref, From, Display)]
#[serde(transparent)]
pub struct Password(String);

impl Password {
    pub fn new<S: Into<String>>(pass: S) -> Self {
        Self(pass.into())
    }
}

#[cfg_attr(feature = "db", derive(sqlx::Type), sqlx(transparent))]
#[derive(Serialize, Deserialize, Debug, Clone, Deref, From, Display)]
#[serde(transparent)]
pub struct PasswordConfirmation(String);

impl PasswordConfirmation {
    pub fn new<S: Into<String>>(pass: S) -> Self {
        Self(pass.into())
    }
}

#[cfg_attr(feature = "db", derive(sqlx::Type), sqlx(transparent))]
#[derive(Serialize, Deserialize, Debug, PartialEq, Eq, Deref, From, Display)]
#[serde(transparent)]
pub struct PassHash(String);

impl PassHash {
    pub fn new<S: Into<String>>(s: S) -> Self {
        Self(s.into())
    }
}

impl PartialEq<PasswordConfirmation> for Password {
    fn eq(&self, other: &PasswordConfirmation) -> bool {
        self.0 == other.0
    }
}

#[cfg_attr(feature = "db", derive(sqlx::Type), sqlx(transparent))]
#[derive(
    Serialize, Deserialize, Copy, Clone, Debug, PartialOrd, PartialEq, Eq, Deref, Display, From,
)]
#[serde(transparent)]
pub struct AccountId(RecordId);

#[cfg_attr(feature = "db", derive(sqlx::FromRow))]
#[derive(Serialize, Deserialize, Debug, PartialEq, Eq)]
pub struct FullAccount {
    pub id: AccountId,
    pub email: Email,
    pub login: Login,
    pub pass_hash: PassHash,
    pub role: Role,
    pub customer_id: uuid::Uuid,
    pub state: AccountState,
}

#[cfg_attr(feature = "db", derive(sqlx::FromRow))]
#[derive(Serialize, Deserialize, Debug)]
pub struct Account {
    pub id: AccountId,
    pub email: Email,
    pub login: Login,
    pub role: Role,
    pub customer_id: uuid::Uuid,
    pub state: AccountState,
}

impl From<FullAccount> for Account {
    fn from(
        FullAccount {
            id,
            email,
            login,
            pass_hash: _,
            role,
            customer_id,
            state,
        }: FullAccount,
    ) -> Self {
        Self {
            id,
            email,
            login,
            role,
            customer_id,
            state,
        }
    }
}

#[cfg_attr(feature = "db", derive(sqlx::Type), sqlx(transparent))]
#[derive(Debug, Copy, Clone, PartialEq, Eq, Hash, Serialize, Deserialize, Deref, From)]
#[serde(transparent)]
pub struct ProductId(RecordId);

impl Display for ProductId {
    fn fmt(&self, f: &mut Formatter<'_>) -> std::fmt::Result {
        f.write_fmt(format_args!("{}", self.0))
    }
}

#[cfg_attr(feature = "db", derive(sqlx::Type), sqlx(transparent))]
#[derive(Debug, Clone, Hash, PartialEq, Eq, Serialize, Deserialize, Deref, Display, From)]
#[serde(transparent)]
pub struct ProductName(String);

impl ProductName {
    pub fn new<S: Into<String>>(s: S) -> Self {
        Self(s.into())
    }

    pub fn into_inner(self) -> String {
        self.0
    }

    pub fn as_str(&self) -> &str {
        &self.0
    }
}

#[cfg_attr(feature = "db", derive(sqlx::Type), sqlx(transparent))]
#[derive(Debug, Clone, Hash, PartialEq, Eq, Serialize, Deserialize, Deref, Display, From)]
#[serde(transparent)]
pub struct ProductShortDesc(String);

impl ProductShortDesc {
    pub fn new<S: Into<String>>(s: S) -> Self {
        Self(s.into())
    }

    pub fn into_inner(self) -> String {
        self.0
    }

    pub fn as_str(&self) -> &str {
        &self.0
    }
}

#[cfg_attr(feature = "db", derive(sqlx::Type), sqlx(transparent))]
#[derive(Debug, Clone, Hash, PartialEq, Eq, Serialize, Deserialize, Deref, Display, From)]
#[serde(transparent)]
pub struct ProductLongDesc(String);

impl ProductLongDesc {
    pub fn into_inner(self) -> String {
        self.0
    }

    pub fn as_str(&self) -> &str {
        &self.0
    }
}

impl ProductLongDesc {
    pub fn new<S: Into<String>>(s: S) -> Self {
        Self(s.into())
    }
}

#[cfg_attr(feature = "db", derive(sqlx::Type), sqlx(transparent))]
#[derive(Debug, Clone, Hash, PartialEq, Eq, Serialize, Deserialize, Deref, Display, From)]
#[serde(transparent)]
pub struct ProductCategory(pub String);

impl ProductCategory {
    pub fn new<S: Into<String>>(s: S) -> Self {
        Self(s.into())
    }

    pub fn as_str(&self) -> &str {
        &self.0
    }
}

#[cfg_attr(feature = "db", derive(sqlx::FromRow))]
#[derive(Debug, Hash, PartialEq, Eq, Serialize, Deserialize)]
pub struct Product {
    pub id: ProductId,
    pub name: ProductName,
    pub short_description: ProductShortDesc,
    pub long_description: ProductLongDesc,
    pub category: Option<ProductCategory>,
    pub price: Price,
    pub deliver_days_flag: Days,
}

#[cfg_attr(feature = "db", derive(sqlx::Type), sqlx(transparent))]
#[derive(Debug, PartialEq, Eq, Copy, Clone, Serialize, Deserialize)]
#[serde(transparent)]
pub struct StockId(pub RecordId);

#[cfg_attr(feature = "db", derive(sqlx::FromRow))]
#[derive(Debug, PartialEq, Eq, Serialize, Deserialize)]
pub struct Stock {
    pub id: StockId,
    pub product_id: ProductId,
    pub quantity: Quantity,
    pub quantity_unit: QuantityUnit,
}

#[cfg_attr(feature = "db", derive(sqlx::Type), sqlx(transparent))]
#[derive(Copy, Clone, Debug, PartialEq, Eq, Serialize, Deserialize, Display, Deref)]
#[serde(transparent)]
pub struct OrderAddressId(RecordId);

#[cfg_attr(feature = "db", derive(sqlx::Type), sqlx(transparent))]
#[derive(Copy, Clone, Debug, PartialEq, Eq, Serialize, Deserialize, Display, Deref)]
#[serde(transparent)]
pub struct OrderId(RecordId);

#[cfg_attr(feature = "db", derive(sqlx::Type), sqlx(transparent))]
#[derive(Clone, Debug, PartialEq, Eq, Serialize, Deserialize, Display, Deref)]
#[serde(transparent)]
pub struct ExtOrderId(String);

impl ExtOrderId {
    pub fn new<S: Into<String>>(s: S) -> Self {
        Self(s.into())
    }

    pub fn into_inner(self) -> String {
        self.0
    }
}

#[cfg_attr(feature = "db", derive(sqlx::FromRow))]
#[derive(Debug, PartialEq, Eq, Serialize, Deserialize)]
pub struct Order {
    pub id: OrderId,
    /// Optional customer account id
    pub buyer_id: Option<AccountId>,
    /// Order status
    pub status: OrderStatus,
    /// ID send to external payment service as an identifier
    pub order_ext_id: uuid::Uuid,
    /// ID received from external payment service as an identifier
    pub service_order_id: Option<String>,
    /// Optional notes given by customer
    pub checkout_notes: Option<String>,
    /// Delivery address
    pub address_id: OrderAddressId,
}

#[cfg_attr(feature = "db", derive(sqlx::FromRow))]
#[derive(Serialize, Deserialize)]
pub struct PublicOrder {
    pub id: OrderId,
    pub buyer_id: Option<AccountId>,
    pub status: OrderStatus,
    pub checkout_notes: String,
    pub address_id: OrderAddressId,
}

impl From<Order> for PublicOrder {
    fn from(
        Order {
            id,
            buyer_id,
            status,
            order_ext_id: _,
            service_order_id: _,
            checkout_notes,
            address_id,
        }: Order,
    ) -> Self {
        Self {
            id,
            buyer_id,
            status,
            checkout_notes: checkout_notes.unwrap_or_default(),
            address_id,
        }
    }
}

#[cfg_attr(feature = "db", derive(sqlx::Type), sqlx(transparent))]
#[derive(Copy, Clone, Debug, PartialEq, Eq, Serialize, Deserialize, Deref)]
pub struct OrderItemId(pub RecordId);

#[cfg_attr(feature = "db", derive(sqlx::FromRow))]
#[derive(Debug, PartialEq, Eq, Serialize, Deserialize)]
pub struct OrderItem {
    pub id: OrderItemId,
    pub product_id: ProductId,
    pub order_id: OrderId,
    pub quantity: Quantity,
    pub quantity_unit: QuantityUnit,
    pub state: OrderItemState,
}

#[cfg_attr(feature = "db", derive(sqlx::Type), sqlx(transparent))]
#[derive(Serialize, Deserialize, PartialEq, Eq, Copy, Clone, Debug, Deref, Display)]
#[serde(transparent)]
pub struct ShoppingCartId(pub RecordId);

#[cfg_attr(feature = "db", derive(sqlx::FromRow))]
#[derive(Debug, PartialEq, Eq, Serialize, Deserialize)]
pub struct ShoppingCart {
    pub id: ShoppingCartId,
    pub buyer_id: AccountId,
    pub payment_method: PaymentMethod,
    pub state: ShoppingCartState,
    pub checkout_notes: Option<String>,
}

#[cfg_attr(feature = "db", derive(sqlx::Type), sqlx(transparent))]
#[derive(PartialEq, Eq, Copy, Clone, Debug, Serialize, Deserialize, Deref, Display)]
#[serde(transparent)]
pub struct ShoppingCartItemId(RecordId);

#[cfg_attr(feature = "db", derive(sqlx::FromRow))]
#[derive(Debug, PartialEq, Eq, Serialize, Deserialize)]
pub struct ShoppingCartItem {
    pub id: ShoppingCartItemId,
    pub product_id: ProductId,
    pub product_variant_id: ProductVariantId,
    pub shopping_cart_id: ShoppingCartId,
    pub quantity: Quantity,
    pub quantity_unit: QuantityUnit,
}

impl ShoppingCartItem {
    pub fn quantity(&self) -> Quantity {
        self.quantity
    }
}

#[cfg_attr(feature = "db", derive(sqlx::Type), sqlx(transparent))]
#[derive(Serialize, Deserialize, Copy, Clone, PartialEq, Eq, Deref, Display, Debug)]
#[serde(transparent)]
pub struct TokenId(RecordId);

#[cfg_attr(feature = "db", derive(sqlx::FromRow))]
#[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize)]
pub struct Token {
    pub id: TokenId,
    pub customer_id: uuid::Uuid,
    pub role: Role,
    /// iss (issuer): Issuer of the JWT
    pub issuer: String,
    /// sub (subject): Subject of the JWT (the user)
    pub subject: i32,
    /// aud (audience): Recipient for which the JWT is intended
    pub audience: Audience,
    /// exp (expiration time): Time after which the JWT expires
    pub expiration_time: chrono::NaiveDateTime,
    /// nbt (not before time): Time before which the JWT must not be accepted
    /// for processing
    pub not_before_time: chrono::NaiveDateTime,
    /// iat (issued at time): Time at which the JWT was issued; can be used to
    /// determine age of the JWT,
    pub issued_at_time: chrono::NaiveDateTime,
    /// jti (JWT ID): Unique identifier; can be used to prevent the JWT from
    /// being replayed (allows a token to be used only once)
    pub jwt_id: uuid::Uuid,
}

#[cfg_attr(feature = "db", derive(sqlx::Type), sqlx(transparent))]
#[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize, Deref, From)]
pub struct AccessToken(Token);

#[cfg_attr(feature = "db", derive(sqlx::Type), sqlx(transparent))]
#[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize, Deref, From)]
pub struct RefreshToken(Token);

impl Token {
    pub fn account_id(&self) -> AccountId {
        AccountId(self.subject)
    }
}

#[cfg_attr(feature = "db", derive(sqlx::Type), sqlx(transparent))]
#[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize, Deref, Display, From)]
pub struct AccessTokenString(String);

impl AccessTokenString {
    pub fn new<S: Into<String>>(s: S) -> Self {
        Self(s.into())
    }
}

impl From<RefreshTokenString> for AccessTokenString {
    fn from(r: RefreshTokenString) -> Self {
        Self(r.0)
    }
}

#[cfg_attr(feature = "db", derive(sqlx::Type), sqlx(transparent))]
#[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize, Deref, Display, From)]
pub struct RefreshTokenString(String);

impl From<AccessTokenString> for RefreshTokenString {
    fn from(r: AccessTokenString) -> Self {
        Self(r.0)
    }
}

impl RefreshTokenString {
    pub fn new<S: Into<String>>(s: S) -> Self {
        Self(s.into())
    }
}

#[cfg_attr(feature = "db", derive(sqlx::Type), sqlx(transparent))]
#[derive(Debug, Hash, PartialEq, Eq, Serialize, Deserialize, Deref, Display, From)]
pub struct LocalPath(String);

impl LocalPath {
    pub fn new<S: Into<String>>(s: S) -> Self {
        Self(s.into())
    }
}

#[cfg_attr(feature = "db", derive(sqlx::Type), sqlx(transparent))]
#[derive(Debug, Hash, PartialEq, Eq, Serialize, Deserialize, Deref, Display, From)]
pub struct UniqueName(String);

impl UniqueName {
    pub fn new<S: Into<String>>(s: S) -> Self {
        Self(s.into())
    }
}

#[cfg_attr(feature = "db", derive(sqlx::Type), sqlx(transparent))]
#[derive(Debug, Hash, PartialEq, Eq, Serialize, Deserialize, Deref, Display, From)]
pub struct FileName(String);

impl FileName {
    pub fn new<S: Into<String>>(s: S) -> Self {
        Self(s.into())
    }
}

#[cfg_attr(feature = "db", derive(sqlx::Type), sqlx(transparent))]
#[derive(
    Debug,
    Copy,
    Clone,
    Hash,
    PartialOrd,
    PartialEq,
    Eq,
    Serialize,
    Deserialize,
    Deref,
    Display,
    From,
)]
pub struct PhotoId(RecordId);

#[cfg_attr(feature = "db", derive(sqlx::Type), sqlx(transparent))]
#[derive(Debug, Hash, Copy, Clone, PartialEq, Eq, Serialize, Deserialize, Deref, Display, From)]
pub struct ProductPhotoId(RecordId);

#[cfg_attr(feature = "db", derive(sqlx::FromRow))]
#[derive(Debug, Hash, PartialEq, Eq, Serialize, Deserialize)]
pub struct Photo {
    pub id: PhotoId,
    pub local_path: LocalPath,
    pub file_name: FileName,
    pub unique_name: UniqueName,
}

#[cfg_attr(feature = "db", derive(sqlx::FromRow))]
#[derive(Debug, Hash, PartialEq, Eq, Serialize, Deserialize)]
pub struct ProductLinkedPhoto {
    pub photo_id: PhotoId,
    pub local_path: LocalPath,
    pub file_name: FileName,
    pub unique_name: UniqueName,
    pub product_id: ProductId,
}

#[cfg_attr(feature = "db", derive(sqlx::FromRow))]
#[derive(Debug, PartialEq, Eq, Serialize, Deserialize)]
pub struct ProductPhoto {
    pub id: ProductPhotoId,
    pub product_id: ProductId,
    pub photo_id: PhotoId,
}

#[cfg_attr(feature = "db", derive(sqlx::Type))]
#[derive(Serialize, Deserialize, Debug)]
#[serde(rename_all = "snake_case")]
pub enum ShippingMethod {
    /// Build-in InPost shipping
    InPost,
    /// Shop owner will ship product manually
    Manual,
}

#[cfg_attr(feature = "db", derive(sqlx::Type), sqlx(transparent))]
#[derive(
    Serialize,
    Deserialize,
    Debug,
    Copy,
    Clone,
    Hash,
    PartialOrd,
    PartialEq,
    Eq,
    Deref,
    Display,
    From,
)]
pub struct AddressId(RecordId);

impl AddressId {
    pub fn new(id: RecordId) -> Self {
        Self(id)
    }
}

#[cfg_attr(feature = "db", derive(sqlx::Type), sqlx(transparent))]
#[derive(
    Serialize,
    Deserialize,
    Debug,
    Clone,
    Default,
    PartialOrd,
    PartialEq,
    Eq,
    Deref,
    DerefMut,
    From,
    Display,
)]
#[serde(transparent)]
pub struct Name(String);

impl Name {
    pub fn new<S: Into<String>>(s: S) -> Self {
        Self(s.into())
    }
}

#[cfg_attr(feature = "db", derive(sqlx::Type), sqlx(transparent))]
#[derive(
    Serialize,
    Deserialize,
    Debug,
    Clone,
    Default,
    PartialOrd,
    PartialEq,
    Eq,
    Deref,
    DerefMut,
    From,
    Display,
)]
#[serde(transparent)]
pub struct Street(String);

impl Street {
    pub fn new<S: Into<String>>(s: S) -> Self {
        Self(s.into())
    }
}

#[cfg_attr(feature = "db", derive(sqlx::Type), sqlx(transparent))]
#[derive(
    Serialize,
    Deserialize,
    Debug,
    Clone,
    Default,
    PartialOrd,
    PartialEq,
    Eq,
    Deref,
    DerefMut,
    From,
    Display,
)]
#[serde(transparent)]
pub struct City(String);

impl City {
    pub fn new<S: Into<String>>(s: S) -> Self {
        Self(s.into())
    }
}

#[cfg_attr(feature = "db", derive(sqlx::Type), sqlx(transparent))]
#[derive(
    Serialize,
    Deserialize,
    Debug,
    Clone,
    Default,
    PartialOrd,
    PartialEq,
    Eq,
    Deref,
    DerefMut,
    From,
    Display,
)]
#[serde(transparent)]
pub struct Country(String);

impl Country {
    pub fn new<S: Into<String>>(s: S) -> Self {
        Self(s.into())
    }
}

#[cfg_attr(feature = "db", derive(sqlx::Type), sqlx(transparent))]
#[derive(
    Serialize,
    Deserialize,
    Debug,
    Clone,
    Default,
    PartialOrd,
    PartialEq,
    Eq,
    Deref,
    DerefMut,
    From,
    Display,
)]
#[serde(transparent)]
pub struct Zip(String);

impl Zip {
    pub fn new<S: Into<String>>(s: S) -> Self {
        Self(s.into())
    }
}

#[cfg_attr(feature = "db", derive(sqlx::FromRow))]
#[derive(Serialize, Deserialize, PartialEq, Eq, Debug)]
pub struct AccountAddress {
    pub id: AddressId,
    pub name: Name,
    pub email: Email,
    pub phone: Phone,
    pub street: Street,
    pub city: City,
    pub country: Country,
    pub zip: Zip,
    pub account_id: AccountId,
    pub is_default: bool,
}

#[cfg_attr(feature = "db", derive(sqlx::FromRow))]
#[derive(Debug, PartialEq, Eq, Serialize, Deserialize)]
pub struct OrderAddress {
    pub id: OrderAddressId,
    pub name: Name,
    pub email: Email,
    pub street: Street,
    pub city: City,
    pub country: Country,
    pub zip: Zip,
    pub phone: Phone,
}

pub mod v2 {
    use derive_more::{Deref, Display, From};
    use serde::{Deserialize, Serialize};

    use crate::NonNegative;
    pub use crate::{
        Day, Days, FileName, Limit, LocalPath, Offset, PhotoId, Price, ProductCategory, ProductId,
        ProductLongDesc, ProductName, ProductPhotoId, ProductShortDesc, Quantity, QuantityUnit,
        RecordId, ShoppingCartId, StockId, UniqueName,
    };

    #[cfg_attr(feature = "db", derive(sqlx::Type), sqlx(transparent))]
    #[derive(Debug, Clone, Hash, PartialEq, Eq, Serialize, Deserialize, Deref, Display, From)]
    #[serde(transparent)]
    pub struct ProductVariantName(String);

    impl ProductVariantName {
        pub fn new<S: Into<String>>(s: S) -> Self {
            Self(s.into())
        }

        pub fn into_inner(self) -> String {
            self.0
        }

        pub fn as_str(&self) -> &str {
            &self.0
        }
    }

    #[cfg_attr(feature = "db", derive(sqlx::Type), sqlx(transparent))]
    #[derive(Debug, Copy, Clone, PartialEq, Eq, Hash, Serialize, Deserialize, Deref, From)]
    #[serde(transparent)]
    pub struct ProductVariantId(pub RecordId);

    #[derive(Debug, PartialEq, serde::Serialize, serde::Deserialize)]
    pub struct DetailedProductVariant {
        pub id: ProductVariantId,
        pub name: ProductVariantName,
        pub short_description: ProductShortDesc,
        pub long_description: ProductLongDesc,
        pub price: Price,
        pub quantity_unit: QuantityUnit,

        pub stocks: Vec<Stock>,

        pub photos: Vec<crate::api::Photo>,

        pub available: bool,
    }

    #[derive(Debug, PartialEq, serde::Serialize, serde::Deserialize)]
    pub struct DetailedProduct {
        pub id: ProductId,
        pub name: ProductName,
        pub category: Option<crate::api::Category>,
        pub deliver_days_flag: Days,
        pub variants: Vec<DetailedProductVariant>,
    }

    impl DetailedProduct {
        pub fn variant_for(&self, variant_id: ProductVariantId) -> Option<&DetailedProductVariant> {
            self.variants.iter().find(|v| v.id == variant_id)
        }
    }

    #[cfg_attr(feature = "db", derive(sqlx::FromRow))]
    #[derive(Debug, Hash, PartialEq, Eq, Serialize, Deserialize)]
    pub struct Product {
        pub id: ProductId,
        pub name: ProductName,
        pub category: Option<ProductCategory>,
        pub deliver_days_flag: Days,
    }

    #[cfg_attr(feature = "db", derive(sqlx::FromRow))]
    #[derive(Debug, Hash, PartialEq, Eq, Serialize, Deserialize)]
    pub struct ProductVariant {
        pub id: ProductVariantId,
        pub product_id: ProductId,
        pub name: ProductVariantName,
        pub short_description: ProductShortDesc,
        pub long_description: ProductLongDesc,
        pub price: Price,
        pub quantity_unit: QuantityUnit,
    }

    #[cfg_attr(feature = "db", derive(sqlx::FromRow))]
    #[derive(Debug, PartialEq, Eq, Serialize, Deserialize)]
    pub struct Stock {
        pub id: StockId,
        pub product_variant_id: ProductVariantId,
        pub quantity: Quantity,
        pub quantity_unit: QuantityUnit,
    }

    #[cfg_attr(feature = "db", derive(sqlx::FromRow))]
    #[derive(Debug, Hash, PartialEq, Eq, Serialize, Deserialize)]
    pub struct Photo {
        pub id: PhotoId,
        pub local_path: LocalPath,
        pub file_name: FileName,
        pub unique_name: UniqueName,
    }

    #[cfg_attr(feature = "db", derive(sqlx::FromRow))]
    #[derive(Debug, Hash, PartialEq, Eq, Serialize, Deserialize)]
    pub struct ProductLinkedPhoto {
        pub photo_id: PhotoId,
        pub local_path: LocalPath,
        pub file_name: FileName,
        pub unique_name: UniqueName,
        pub product_variant_id: ProductVariantId,
    }

    #[cfg_attr(feature = "db", derive(sqlx::FromRow))]
    #[derive(Debug, PartialEq, Eq, Serialize, Deserialize)]
    pub struct ProductPhoto {
        pub id: ProductPhotoId,
        pub product_variant_id: ProductVariantId,
        pub photo_id: PhotoId,
    }

    #[cfg_attr(feature = "db", derive(sqlx::Type), sqlx(transparent))]
    #[derive(
        Debug,
        Clone,
        Copy,
        Default,
        PartialOrd,
        PartialEq,
        Eq,
        Hash,
        Serialize,
        Deserialize,
        Deref,
        From,
        Display,
    )]
    #[serde(transparent)]
    pub struct CategoryId(NonNegative);

    #[cfg_attr(feature = "db", derive(sqlx::Type), sqlx(transparent))]
    #[derive(
        Debug,
        Clone,
        Default,
        PartialOrd,
        PartialEq,
        Eq,
        Hash,
        Serialize,
        Deserialize,
        Deref,
        From,
        Display,
    )]
    #[serde(transparent)]
    pub struct CategoryName(pub String);

    impl<'s> From<&'s str> for CategoryName {
        fn from(value: &'s str) -> Self {
            Self(value.into())
        }
    }

    #[cfg_attr(feature = "db", derive(sqlx::Type), sqlx(transparent))]
    #[derive(
        Debug,
        Clone,
        Default,
        PartialOrd,
        PartialEq,
        Eq,
        Hash,
        Serialize,
        Deserialize,
        Deref,
        From,
        Display,
    )]
    #[serde(transparent)]
    pub struct CategoryKey(pub String);

    impl<'s> From<&'s str> for CategoryKey {
        fn from(value: &'s str) -> Self {
            Self(value.into())
        }
    }

    #[cfg_attr(feature = "db", derive(sqlx::Type), sqlx(transparent))]
    #[derive(
        Debug,
        Clone,
        Default,
        PartialOrd,
        PartialEq,
        Eq,
        Hash,
        Serialize,
        Deserialize,
        Deref,
        From,
        Display,
    )]
    #[serde(transparent)]
    pub struct CategorySvg(pub String);

    impl<'s> From<&'s str> for CategorySvg {
        fn from(value: &'s str) -> Self {
            Self(value.into())
        }
    }

    #[cfg_attr(feature = "db", derive(sqlx::FromRow))]
    #[derive(Debug, PartialEq, Eq, Serialize, Deserialize)]
    pub struct Category {
        pub id: CategoryId,
        pub parent_id: Option<CategoryId>,
        pub name: CategoryName,
        pub key: CategoryKey,
        pub svg: CategorySvg,
    }
}