#![allow(unused_imports)]
use serde_json::Value;
use bigdecimal::BigDecimal;
use chrono::{Date, NaiveDateTime, NaiveDate, DateTime, FixedOffset, Utc};
use crate::models::*;
use crate::date_serializer;
use crate::date_serializer_opt;
use crate::serialize_quoted_numbers;
use crate::serialize_quoted_numbers_opt;
#[derive(Debug, Serialize, Deserialize, PartialEq, Clone)]
pub struct DayUsageData {
#[serde(rename = "countDailyDataPoints")]
#[serde(default)]
count_daily_data_points: Option<i32>,
#[serde(rename = "day")]
#[serde(default)]
day: Option<String>,
#[serde(rename = "discount")]
#[serde(default)]
discount: Option<f32>,
#[serde(rename = "dpmPerContainerHostQuota")]
#[serde(default)]
dpm_per_container_host_quota: Option<i64>,
#[serde(rename = "dpmPerHostQuota")]
#[serde(default)]
dpm_per_host_quota: Option<i64>,
#[serde(rename = "fixedMonthlyPrice")]
#[serde(default)]
fixed_monthly_price: Option<f32>,
#[serde(rename = "fixedMonthlyPricePerHour")]
#[serde(default)]
fixed_monthly_price_per_hour: Option<f32>,
#[serde(rename = "freeContainersPerHost")]
#[serde(default)]
free_containers_per_host: Option<i32>,
#[serde(rename = "id")]
#[serde(default)]
id: Option<i64>,
#[serde(rename = "kiloDpmOveragePricePerHour")]
#[serde(default)]
kilo_dpm_overage_price_per_hour: Option<f32>,
#[serde(rename = "planType")]
#[serde(default)]
plan_type: Option<String>,
#[serde(rename = "pricePerContainerHostHour")]
#[serde(default)]
price_per_container_host_hour: Option<f32>,
#[serde(rename = "pricePerContainerHour")]
#[serde(default)]
price_per_container_hour: Option<f32>,
#[serde(rename = "pricePerServerHour")]
#[serde(default)]
price_per_server_hour: Option<f32>,
#[serde(rename = "sumNumberOfContainerHosts")]
#[serde(default)]
sum_number_of_container_hosts: Option<i32>,
#[serde(rename = "sumNumberOfContainers")]
#[serde(default)]
sum_number_of_containers: Option<i32>,
#[serde(rename = "sumNumberOfServers")]
#[serde(default)]
sum_number_of_servers: Option<i32>,
#[serde(rename = "usageAmount")]
#[serde(default)]
usage_amount: Option<f32>,
#[serde(rename = "usedPlan")]
#[serde(default)]
used_plan: Option<String>,
#[serde(rename = "userDiscount")]
#[serde(default)]
user_discount: Option<f32>
}
impl DayUsageData {
pub fn new() -> DayUsageData {
DayUsageData {
count_daily_data_points: None,
day: None,
discount: None,
dpm_per_container_host_quota: None,
dpm_per_host_quota: None,
fixed_monthly_price: None,
fixed_monthly_price_per_hour: None,
free_containers_per_host: None,
id: None,
kilo_dpm_overage_price_per_hour: None,
plan_type: None,
price_per_container_host_hour: None,
price_per_container_hour: None,
price_per_server_hour: None,
sum_number_of_container_hosts: None,
sum_number_of_containers: None,
sum_number_of_servers: None,
usage_amount: None,
used_plan: None,
user_discount: None
}
}
pub fn set_count_daily_data_points(&mut self, count_daily_data_points: i32) {
self.count_daily_data_points = Some(count_daily_data_points);
}
pub fn with_count_daily_data_points(mut self, count_daily_data_points: i32) -> DayUsageData {
self.count_daily_data_points = Some(count_daily_data_points);
self
}
pub fn count_daily_data_points(&self) -> Option<&i32> {
self.count_daily_data_points.as_ref()
}
pub fn reset_count_daily_data_points(&mut self) {
self.count_daily_data_points = None;
}
pub fn set_day(&mut self, day: String) {
self.day = Some(day);
}
pub fn with_day(mut self, day: String) -> DayUsageData {
self.day = Some(day);
self
}
pub fn day(&self) -> Option<&String> {
self.day.as_ref()
}
pub fn reset_day(&mut self) {
self.day = None;
}
pub fn set_discount(&mut self, discount: f32) {
self.discount = Some(discount);
}
pub fn with_discount(mut self, discount: f32) -> DayUsageData {
self.discount = Some(discount);
self
}
pub fn discount(&self) -> Option<&f32> {
self.discount.as_ref()
}
pub fn reset_discount(&mut self) {
self.discount = None;
}
pub fn set_dpm_per_container_host_quota(&mut self, dpm_per_container_host_quota: i64) {
self.dpm_per_container_host_quota = Some(dpm_per_container_host_quota);
}
pub fn with_dpm_per_container_host_quota(mut self, dpm_per_container_host_quota: i64) -> DayUsageData {
self.dpm_per_container_host_quota = Some(dpm_per_container_host_quota);
self
}
pub fn dpm_per_container_host_quota(&self) -> Option<&i64> {
self.dpm_per_container_host_quota.as_ref()
}
pub fn reset_dpm_per_container_host_quota(&mut self) {
self.dpm_per_container_host_quota = None;
}
pub fn set_dpm_per_host_quota(&mut self, dpm_per_host_quota: i64) {
self.dpm_per_host_quota = Some(dpm_per_host_quota);
}
pub fn with_dpm_per_host_quota(mut self, dpm_per_host_quota: i64) -> DayUsageData {
self.dpm_per_host_quota = Some(dpm_per_host_quota);
self
}
pub fn dpm_per_host_quota(&self) -> Option<&i64> {
self.dpm_per_host_quota.as_ref()
}
pub fn reset_dpm_per_host_quota(&mut self) {
self.dpm_per_host_quota = None;
}
pub fn set_fixed_monthly_price(&mut self, fixed_monthly_price: f32) {
self.fixed_monthly_price = Some(fixed_monthly_price);
}
pub fn with_fixed_monthly_price(mut self, fixed_monthly_price: f32) -> DayUsageData {
self.fixed_monthly_price = Some(fixed_monthly_price);
self
}
pub fn fixed_monthly_price(&self) -> Option<&f32> {
self.fixed_monthly_price.as_ref()
}
pub fn reset_fixed_monthly_price(&mut self) {
self.fixed_monthly_price = None;
}
pub fn set_fixed_monthly_price_per_hour(&mut self, fixed_monthly_price_per_hour: f32) {
self.fixed_monthly_price_per_hour = Some(fixed_monthly_price_per_hour);
}
pub fn with_fixed_monthly_price_per_hour(mut self, fixed_monthly_price_per_hour: f32) -> DayUsageData {
self.fixed_monthly_price_per_hour = Some(fixed_monthly_price_per_hour);
self
}
pub fn fixed_monthly_price_per_hour(&self) -> Option<&f32> {
self.fixed_monthly_price_per_hour.as_ref()
}
pub fn reset_fixed_monthly_price_per_hour(&mut self) {
self.fixed_monthly_price_per_hour = None;
}
pub fn set_free_containers_per_host(&mut self, free_containers_per_host: i32) {
self.free_containers_per_host = Some(free_containers_per_host);
}
pub fn with_free_containers_per_host(mut self, free_containers_per_host: i32) -> DayUsageData {
self.free_containers_per_host = Some(free_containers_per_host);
self
}
pub fn free_containers_per_host(&self) -> Option<&i32> {
self.free_containers_per_host.as_ref()
}
pub fn reset_free_containers_per_host(&mut self) {
self.free_containers_per_host = None;
}
pub fn set_id(&mut self, id: i64) {
self.id = Some(id);
}
pub fn with_id(mut self, id: i64) -> DayUsageData {
self.id = Some(id);
self
}
pub fn id(&self) -> Option<&i64> {
self.id.as_ref()
}
pub fn reset_id(&mut self) {
self.id = None;
}
pub fn set_kilo_dpm_overage_price_per_hour(&mut self, kilo_dpm_overage_price_per_hour: f32) {
self.kilo_dpm_overage_price_per_hour = Some(kilo_dpm_overage_price_per_hour);
}
pub fn with_kilo_dpm_overage_price_per_hour(mut self, kilo_dpm_overage_price_per_hour: f32) -> DayUsageData {
self.kilo_dpm_overage_price_per_hour = Some(kilo_dpm_overage_price_per_hour);
self
}
pub fn kilo_dpm_overage_price_per_hour(&self) -> Option<&f32> {
self.kilo_dpm_overage_price_per_hour.as_ref()
}
pub fn reset_kilo_dpm_overage_price_per_hour(&mut self) {
self.kilo_dpm_overage_price_per_hour = None;
}
pub fn set_plan_type(&mut self, plan_type: String) {
self.plan_type = Some(plan_type);
}
pub fn with_plan_type(mut self, plan_type: String) -> DayUsageData {
self.plan_type = Some(plan_type);
self
}
pub fn plan_type(&self) -> Option<&String> {
self.plan_type.as_ref()
}
pub fn reset_plan_type(&mut self) {
self.plan_type = None;
}
pub fn set_price_per_container_host_hour(&mut self, price_per_container_host_hour: f32) {
self.price_per_container_host_hour = Some(price_per_container_host_hour);
}
pub fn with_price_per_container_host_hour(mut self, price_per_container_host_hour: f32) -> DayUsageData {
self.price_per_container_host_hour = Some(price_per_container_host_hour);
self
}
pub fn price_per_container_host_hour(&self) -> Option<&f32> {
self.price_per_container_host_hour.as_ref()
}
pub fn reset_price_per_container_host_hour(&mut self) {
self.price_per_container_host_hour = None;
}
pub fn set_price_per_container_hour(&mut self, price_per_container_hour: f32) {
self.price_per_container_hour = Some(price_per_container_hour);
}
pub fn with_price_per_container_hour(mut self, price_per_container_hour: f32) -> DayUsageData {
self.price_per_container_hour = Some(price_per_container_hour);
self
}
pub fn price_per_container_hour(&self) -> Option<&f32> {
self.price_per_container_hour.as_ref()
}
pub fn reset_price_per_container_hour(&mut self) {
self.price_per_container_hour = None;
}
pub fn set_price_per_server_hour(&mut self, price_per_server_hour: f32) {
self.price_per_server_hour = Some(price_per_server_hour);
}
pub fn with_price_per_server_hour(mut self, price_per_server_hour: f32) -> DayUsageData {
self.price_per_server_hour = Some(price_per_server_hour);
self
}
pub fn price_per_server_hour(&self) -> Option<&f32> {
self.price_per_server_hour.as_ref()
}
pub fn reset_price_per_server_hour(&mut self) {
self.price_per_server_hour = None;
}
pub fn set_sum_number_of_container_hosts(&mut self, sum_number_of_container_hosts: i32) {
self.sum_number_of_container_hosts = Some(sum_number_of_container_hosts);
}
pub fn with_sum_number_of_container_hosts(mut self, sum_number_of_container_hosts: i32) -> DayUsageData {
self.sum_number_of_container_hosts = Some(sum_number_of_container_hosts);
self
}
pub fn sum_number_of_container_hosts(&self) -> Option<&i32> {
self.sum_number_of_container_hosts.as_ref()
}
pub fn reset_sum_number_of_container_hosts(&mut self) {
self.sum_number_of_container_hosts = None;
}
pub fn set_sum_number_of_containers(&mut self, sum_number_of_containers: i32) {
self.sum_number_of_containers = Some(sum_number_of_containers);
}
pub fn with_sum_number_of_containers(mut self, sum_number_of_containers: i32) -> DayUsageData {
self.sum_number_of_containers = Some(sum_number_of_containers);
self
}
pub fn sum_number_of_containers(&self) -> Option<&i32> {
self.sum_number_of_containers.as_ref()
}
pub fn reset_sum_number_of_containers(&mut self) {
self.sum_number_of_containers = None;
}
pub fn set_sum_number_of_servers(&mut self, sum_number_of_servers: i32) {
self.sum_number_of_servers = Some(sum_number_of_servers);
}
pub fn with_sum_number_of_servers(mut self, sum_number_of_servers: i32) -> DayUsageData {
self.sum_number_of_servers = Some(sum_number_of_servers);
self
}
pub fn sum_number_of_servers(&self) -> Option<&i32> {
self.sum_number_of_servers.as_ref()
}
pub fn reset_sum_number_of_servers(&mut self) {
self.sum_number_of_servers = None;
}
pub fn set_usage_amount(&mut self, usage_amount: f32) {
self.usage_amount = Some(usage_amount);
}
pub fn with_usage_amount(mut self, usage_amount: f32) -> DayUsageData {
self.usage_amount = Some(usage_amount);
self
}
pub fn usage_amount(&self) -> Option<&f32> {
self.usage_amount.as_ref()
}
pub fn reset_usage_amount(&mut self) {
self.usage_amount = None;
}
pub fn set_used_plan(&mut self, used_plan: String) {
self.used_plan = Some(used_plan);
}
pub fn with_used_plan(mut self, used_plan: String) -> DayUsageData {
self.used_plan = Some(used_plan);
self
}
pub fn used_plan(&self) -> Option<&String> {
self.used_plan.as_ref()
}
pub fn reset_used_plan(&mut self) {
self.used_plan = None;
}
pub fn set_user_discount(&mut self, user_discount: f32) {
self.user_discount = Some(user_discount);
}
pub fn with_user_discount(mut self, user_discount: f32) -> DayUsageData {
self.user_discount = Some(user_discount);
self
}
pub fn user_discount(&self) -> Option<&f32> {
self.user_discount.as_ref()
}
pub fn reset_user_discount(&mut self) {
self.user_discount = None;
}
pub fn validate(&self) {
}
}