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
128
129
130
131

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

#[derive(Serialize, Deserialize, Debug, Clone, Validate)]
pub struct UpdateMenuBody {
    pub id: String,
    pub number_of_authorized_menus: i32,
    pub number_of_published_menus: i32,
    pub company: Option<String>,
    pub identifier: Option<String>,
    pub titles: Option<Vec<UpdateMenuTitleBody>>,
    pub names: Option<Vec<UpdateMenuNameBody>>,
    pub descriptions: Option<Vec<UpdateMenuDescriptionBody>>,
    pub sites: Option<Vec<MenuSiteBody>>,
    pub languages: Option<Vec<MenuLanguageBody>>,
    pub currency: Option<String>,
    pub delivery_settings: Option<MenuDeliverySettingsBody>,
    pub logo: Option<String>,
    pub copied_logos: Option<Vec<MenuCopiedLogoBody>>,
    pub screenshots: Option<Vec<MenuScreenshotBody>>,
    pub characteristics: Option<Vec<MenuCharacteristicBody>>,
    pub default_prep_time: Option<DefaultPrepTimeBody>,
    pub is_published: Option<bool>,
}

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

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

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

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

#[derive(Serialize, Deserialize, Debug, Clone)]
pub struct MenuLanguageBody {
    pub language: Option<String>,
    pub is_main: Option<bool>,
}

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

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

#[derive(Serialize, Deserialize, Debug, Clone)]
pub struct MenuScreenshotBody {
    pub file_id: Option<String>,
    pub is_visible: Option<bool>
}

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

#[derive(Serialize, Deserialize, Debug, Clone, Validate)]
pub struct DefaultPrepTimeBody {
    pub min: Option<i32>,
    pub max: Option<i32>
}

#[derive(Serialize, Deserialize, Debug, Clone)]
pub struct UpdateMenuResult {
    pub success: bool,
    pub is_reached: bool,
}

#[derive(Debug, Display)]
pub enum UpdateMenuError {
    #[display(fmt = "invalid_object_id")]
    InvalidObjectId,
    #[display(fmt = "menu_not_found")]
    MenuNotFound,
    #[display(fmt = "identifier_already_exists")]
    IdentifierExists,
    #[display(fmt = "identifier_is_not_alphabectic")]
    IdentifierIsNotAplhabetic,
    #[display(fmt = "maximum_published_menu_reached")]
    MaximumReached,
    Default(String),
}

impl ResponseError for UpdateMenuError {
    fn error_response(&self) -> HttpResponse {
        match self {
            UpdateMenuError::InvalidObjectId => {
                HttpResponse::NotAcceptable().body("invalid_object_id")
            }
            UpdateMenuError::MenuNotFound => HttpResponse::Conflict().body("menu_not_found"),
            UpdateMenuError::IdentifierExists => {
                HttpResponse::Conflict().body("identifier_already_exists")
            }
            UpdateMenuError::IdentifierIsNotAplhabetic => {
                HttpResponse::NotAcceptable().body("identifier_is_not_alphabectic")
            }
            UpdateMenuError::MaximumReached => {
                HttpResponse::Gone().body("maximum_published_menu_reached")
            }
            UpdateMenuError::Default(error) => HttpResponse::BadRequest().body(error),
        }
    }
}