1
  2
  3
  4
  5
  6
  7
  8
  9
 10
 11
 12
 13
 14
 15
 16
 17
 18
 19
 20
 21
 22
 23
 24
 25
 26
 27
 28
 29
 30
 31
 32
 33
 34
 35
 36
 37
 38
 39
 40
 41
 42
 43
 44
 45
 46
 47
 48
 49
 50
 51
 52
 53
 54
 55
 56
 57
 58
 59
 60
 61
 62
 63
 64
 65
 66
 67
 68
 69
 70
 71
 72
 73
 74
 75
 76
 77
 78
 79
 80
 81
 82
 83
 84
 85
 86
 87
 88
 89
 90
 91
 92
 93
 94
 95
 96
 97
 98
 99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127

use actix_web::{HttpResponse, ResponseError};
use derive_more::Display;
use serde::{Deserialize, Serialize};
use validator::Validate;

#[derive(Serialize, Deserialize, Debug, Clone, Validate)]
pub struct CreateCategoryProductBody {
    pub category: Option<String>,
    pub identifier: Option<String>,
    pub names: Option<Vec<CreateCategoryProductNameBody>>,
    pub short_descriptions: Option<Vec<CreateCategoryProductDescriptionBody>>,
    pub long_descriptions: Option<Vec<CreateCategoryProductDescriptionBody>>,
    pub kinds: Option<Vec<CreateCategoryProductKindBody>>,
    pub tags: Option<Vec<String>>,
    pub vendor: Option<String>,
    pub unit: Option<CategoryProductUnitBody>,
    pub picture: Option<String>,
    pub copied_pictures: Option<Vec<CategoryProductCopiedPictureBody>>,
    pub price: Option<CategoryProductPriceBody>,
    pub discount: Option<CategoryProductDiscountBody>,
    pub buying_price: Option<CategoryProductPriceBody>,
    pub quantity: Option<f64>,
    pub sites: Option<Vec<CategoryProductSiteBody>>,
    pub options: Option<Vec<CategoryProductOptionsBody>>,
    pub variants: Option<Vec<CategoryProductVariantBody>>,
    pub order: Option<i32>,
    pub is_published: Option<bool>,
}

#[derive(Serialize, Deserialize, Debug, Clone)]
pub struct CreateCategoryProductNameBody {
    pub language_code: Option<String>,
    pub value: Option<String>,
}

#[derive(Serialize, Deserialize, Debug, Clone)]
pub struct CreateCategoryProductDescriptionBody {
    pub language_code: Option<String>,
    pub value: Option<String>,
}

#[derive(Serialize, Deserialize, Debug, Clone)]
pub struct CreateCategoryProductKindBody {
    pub language_code: Option<String>,
    pub value: Option<String>,
}

#[derive(Serialize, Deserialize, Debug, Clone)]
pub struct CategoryProductUnitBody {
    pub kind: Option<String>,
    pub default: Option<f64>,
}

#[derive(Serialize, Deserialize, Debug, Clone)]
pub struct CategoryProductCopiedPictureBody {
    pub id: Option<String>,
    pub quality: Option<String>,
}

#[derive(Serialize, Deserialize, Debug, Clone)]
pub struct CategoryProductPriceBody {
    pub value: Option<f64>,
    pub currency: Option<String>,
}

#[derive(Serialize, Deserialize, Debug, Clone)]
pub struct CategoryProductDiscountBody {
    pub percentage: Option<i32>,
    pub price: Option<CategoryProductPriceBody>,
}

#[derive(Serialize, Deserialize, Debug, Clone)]
pub struct CategoryProductSiteBody {
    pub site: Option<String>,
    pub price: Option<CategoryProductPriceBody>,
    pub discount: Option<CategoryProductDiscountBody>,
    pub buying_price: Option<CategoryProductPriceBody>,
    pub quantity: Option<f64>,
}

#[derive(Serialize, Deserialize, Debug, Clone)]
pub struct CategoryProductOptionsBody {
    pub number: Option<i32>,
    pub kind: Option<String>,
    pub values: Option<Vec<String>>,
}

#[derive(Serialize, Deserialize, Debug, Clone)]
pub struct CategoryProductVariantBody {
    pub variant: Option<Vec<String>>,
    pub picture: Option<String>,
    pub copied_pictures: Option<Vec<CategoryProductCopiedPictureBody>>,
    pub barcode: Option<String>,
    pub price: Option<CategoryProductPriceBody>,
    pub discount: Option<CategoryProductDiscountBody>,
    pub buying_price: Option<CategoryProductPriceBody>,
    pub quantity: Option<f64>,
    pub sites: Option<Vec<CategoryProductSiteBody>>,
}

#[derive(Serialize, Deserialize, Debug, Clone)]
pub struct CreateCategoryProductResult {
    pub id: String,
}

#[derive(Debug, Display)]
pub enum CreateCategoryProductError {
    #[display(fmt = "identifier_already_exists")]
    IdentifierExists,
    #[display(fmt = "identifier_is_not_alphabectic")]
    IdentifierIsNotAlphabetic,
    Default(String),
}

impl ResponseError for CreateCategoryProductError {
    fn error_response(&self) -> HttpResponse {
        match self {
            CreateCategoryProductError::IdentifierExists => {
                HttpResponse::Conflict().body("identifier_already_exists")
            }
            CreateCategoryProductError::IdentifierIsNotAlphabetic => {
                HttpResponse::NotAcceptable().body("identifier_is_not_alphabectic")
            }
            CreateCategoryProductError::Default(error) => HttpResponse::BadRequest().body(error),
        }
    }
}