#![allow(unused_imports)]
use serde_json::Value;
use bigdecimal::BigDecimal;
use chrono::{NaiveDateTime, DateTime, FixedOffset, Utc};
use crate::models::*;
#[derive(Debug, Serialize, Deserialize, Clone)]
pub struct Financial {
#[serde(rename = "symbol")]
symbol: String, #[serde(rename = "reportDate")]
report_date: String, #[serde(rename = "reportDateStr")]
report_date_str: String, #[serde(rename = "grossProfit")]
gross_profit: Option<i64>, #[serde(rename = "costOfRevenue")]
cost_of_revenue: Option<i64>, #[serde(rename = "operatingRevenue")]
operating_revenue: Option<i64>, #[serde(rename = "totalRevenue")]
total_revenue: Option<i64>, #[serde(rename = "operatingIncome")]
operating_income: Option<i64>, #[serde(rename = "netIncome")]
net_income: Option<i64>, #[serde(rename = "researchAndDevelopment")]
research_and_development: Option<i64>, #[serde(rename = "operatingExpense")]
operating_expense: Option<i64>, #[serde(rename = "currentAssets")]
current_assets: Option<i64>, #[serde(rename = "totalAssets")]
total_assets: Option<i64>, #[serde(rename = "totalLiabilities")]
total_liabilities: Option<i64>, #[serde(rename = "currentCash")]
current_cash: Option<i64>, #[serde(rename = "currentDebt")]
current_debt: Option<i64>, #[serde(rename = "totalCash")]
total_cash: Option<i64>, #[serde(rename = "totalDebt")]
total_debt: Option<i64>, #[serde(rename = "shareholderEquity")]
shareholder_equity: Option<i64>, #[serde(rename = "cashChange")]
cash_change: Option<i64>, #[serde(rename = "cashFlow")]
cash_flow: Option<i64>, #[serde(rename = "operatingGainsLosses")]
operating_gains_losses: Option<f32>
}
impl Financial {
pub fn new(symbol: String, report_date: String, report_date_str: String, ) -> Financial {
Financial {
symbol: symbol,
report_date: report_date,
report_date_str: report_date_str,
gross_profit: None,
cost_of_revenue: None,
operating_revenue: None,
total_revenue: None,
operating_income: None,
net_income: None,
research_and_development: None,
operating_expense: None,
current_assets: None,
total_assets: None,
total_liabilities: None,
current_cash: None,
current_debt: None,
total_cash: None,
total_debt: None,
shareholder_equity: None,
cash_change: None,
cash_flow: None,
operating_gains_losses: None
}
}
pub fn set_symbol(&mut self, symbol: String) {
self.symbol = symbol;
}
pub fn with_symbol(mut self, symbol: String) -> Financial {
self.symbol = symbol;
self
}
pub fn symbol(&self) -> &String {
&self.symbol
}
pub fn set_report_date(&mut self, report_date: String) {
self.report_date = report_date;
}
pub fn with_report_date(mut self, report_date: String) -> Financial {
self.report_date = report_date;
self
}
pub fn report_date(&self) -> &String {
&self.report_date
}
pub fn set_report_date_str(&mut self, report_date_str: String) {
self.report_date_str = report_date_str;
}
pub fn with_report_date_str(mut self, report_date_str: String) -> Financial {
self.report_date_str = report_date_str;
self
}
pub fn report_date_str(&self) -> &String {
&self.report_date_str
}
pub fn set_gross_profit(&mut self, gross_profit: i64) {
self.gross_profit = Some(gross_profit);
}
pub fn with_gross_profit(mut self, gross_profit: i64) -> Financial {
self.gross_profit = Some(gross_profit);
self
}
pub fn gross_profit(&self) -> Option<&i64> {
self.gross_profit.as_ref()
}
pub fn reset_gross_profit(&mut self) {
self.gross_profit = None;
}
pub fn set_cost_of_revenue(&mut self, cost_of_revenue: i64) {
self.cost_of_revenue = Some(cost_of_revenue);
}
pub fn with_cost_of_revenue(mut self, cost_of_revenue: i64) -> Financial {
self.cost_of_revenue = Some(cost_of_revenue);
self
}
pub fn cost_of_revenue(&self) -> Option<&i64> {
self.cost_of_revenue.as_ref()
}
pub fn reset_cost_of_revenue(&mut self) {
self.cost_of_revenue = None;
}
pub fn set_operating_revenue(&mut self, operating_revenue: i64) {
self.operating_revenue = Some(operating_revenue);
}
pub fn with_operating_revenue(mut self, operating_revenue: i64) -> Financial {
self.operating_revenue = Some(operating_revenue);
self
}
pub fn operating_revenue(&self) -> Option<&i64> {
self.operating_revenue.as_ref()
}
pub fn reset_operating_revenue(&mut self) {
self.operating_revenue = None;
}
pub fn set_total_revenue(&mut self, total_revenue: i64) {
self.total_revenue = Some(total_revenue);
}
pub fn with_total_revenue(mut self, total_revenue: i64) -> Financial {
self.total_revenue = Some(total_revenue);
self
}
pub fn total_revenue(&self) -> Option<&i64> {
self.total_revenue.as_ref()
}
pub fn reset_total_revenue(&mut self) {
self.total_revenue = None;
}
pub fn set_operating_income(&mut self, operating_income: i64) {
self.operating_income = Some(operating_income);
}
pub fn with_operating_income(mut self, operating_income: i64) -> Financial {
self.operating_income = Some(operating_income);
self
}
pub fn operating_income(&self) -> Option<&i64> {
self.operating_income.as_ref()
}
pub fn reset_operating_income(&mut self) {
self.operating_income = None;
}
pub fn set_net_income(&mut self, net_income: i64) {
self.net_income = Some(net_income);
}
pub fn with_net_income(mut self, net_income: i64) -> Financial {
self.net_income = Some(net_income);
self
}
pub fn net_income(&self) -> Option<&i64> {
self.net_income.as_ref()
}
pub fn reset_net_income(&mut self) {
self.net_income = None;
}
pub fn set_research_and_development(&mut self, research_and_development: i64) {
self.research_and_development = Some(research_and_development);
}
pub fn with_research_and_development(mut self, research_and_development: i64) -> Financial {
self.research_and_development = Some(research_and_development);
self
}
pub fn research_and_development(&self) -> Option<&i64> {
self.research_and_development.as_ref()
}
pub fn reset_research_and_development(&mut self) {
self.research_and_development = None;
}
pub fn set_operating_expense(&mut self, operating_expense: i64) {
self.operating_expense = Some(operating_expense);
}
pub fn with_operating_expense(mut self, operating_expense: i64) -> Financial {
self.operating_expense = Some(operating_expense);
self
}
pub fn operating_expense(&self) -> Option<&i64> {
self.operating_expense.as_ref()
}
pub fn reset_operating_expense(&mut self) {
self.operating_expense = None;
}
pub fn set_current_assets(&mut self, current_assets: i64) {
self.current_assets = Some(current_assets);
}
pub fn with_current_assets(mut self, current_assets: i64) -> Financial {
self.current_assets = Some(current_assets);
self
}
pub fn current_assets(&self) -> Option<&i64> {
self.current_assets.as_ref()
}
pub fn reset_current_assets(&mut self) {
self.current_assets = None;
}
pub fn set_total_assets(&mut self, total_assets: i64) {
self.total_assets = Some(total_assets);
}
pub fn with_total_assets(mut self, total_assets: i64) -> Financial {
self.total_assets = Some(total_assets);
self
}
pub fn total_assets(&self) -> Option<&i64> {
self.total_assets.as_ref()
}
pub fn reset_total_assets(&mut self) {
self.total_assets = None;
}
pub fn set_total_liabilities(&mut self, total_liabilities: i64) {
self.total_liabilities = Some(total_liabilities);
}
pub fn with_total_liabilities(mut self, total_liabilities: i64) -> Financial {
self.total_liabilities = Some(total_liabilities);
self
}
pub fn total_liabilities(&self) -> Option<&i64> {
self.total_liabilities.as_ref()
}
pub fn reset_total_liabilities(&mut self) {
self.total_liabilities = None;
}
pub fn set_current_cash(&mut self, current_cash: i64) {
self.current_cash = Some(current_cash);
}
pub fn with_current_cash(mut self, current_cash: i64) -> Financial {
self.current_cash = Some(current_cash);
self
}
pub fn current_cash(&self) -> Option<&i64> {
self.current_cash.as_ref()
}
pub fn reset_current_cash(&mut self) {
self.current_cash = None;
}
pub fn set_current_debt(&mut self, current_debt: i64) {
self.current_debt = Some(current_debt);
}
pub fn with_current_debt(mut self, current_debt: i64) -> Financial {
self.current_debt = Some(current_debt);
self
}
pub fn current_debt(&self) -> Option<&i64> {
self.current_debt.as_ref()
}
pub fn reset_current_debt(&mut self) {
self.current_debt = None;
}
pub fn set_total_cash(&mut self, total_cash: i64) {
self.total_cash = Some(total_cash);
}
pub fn with_total_cash(mut self, total_cash: i64) -> Financial {
self.total_cash = Some(total_cash);
self
}
pub fn total_cash(&self) -> Option<&i64> {
self.total_cash.as_ref()
}
pub fn reset_total_cash(&mut self) {
self.total_cash = None;
}
pub fn set_total_debt(&mut self, total_debt: i64) {
self.total_debt = Some(total_debt);
}
pub fn with_total_debt(mut self, total_debt: i64) -> Financial {
self.total_debt = Some(total_debt);
self
}
pub fn total_debt(&self) -> Option<&i64> {
self.total_debt.as_ref()
}
pub fn reset_total_debt(&mut self) {
self.total_debt = None;
}
pub fn set_shareholder_equity(&mut self, shareholder_equity: i64) {
self.shareholder_equity = Some(shareholder_equity);
}
pub fn with_shareholder_equity(mut self, shareholder_equity: i64) -> Financial {
self.shareholder_equity = Some(shareholder_equity);
self
}
pub fn shareholder_equity(&self) -> Option<&i64> {
self.shareholder_equity.as_ref()
}
pub fn reset_shareholder_equity(&mut self) {
self.shareholder_equity = None;
}
pub fn set_cash_change(&mut self, cash_change: i64) {
self.cash_change = Some(cash_change);
}
pub fn with_cash_change(mut self, cash_change: i64) -> Financial {
self.cash_change = Some(cash_change);
self
}
pub fn cash_change(&self) -> Option<&i64> {
self.cash_change.as_ref()
}
pub fn reset_cash_change(&mut self) {
self.cash_change = None;
}
pub fn set_cash_flow(&mut self, cash_flow: i64) {
self.cash_flow = Some(cash_flow);
}
pub fn with_cash_flow(mut self, cash_flow: i64) -> Financial {
self.cash_flow = Some(cash_flow);
self
}
pub fn cash_flow(&self) -> Option<&i64> {
self.cash_flow.as_ref()
}
pub fn reset_cash_flow(&mut self) {
self.cash_flow = None;
}
pub fn set_operating_gains_losses(&mut self, operating_gains_losses: f32) {
self.operating_gains_losses = Some(operating_gains_losses);
}
pub fn with_operating_gains_losses(mut self, operating_gains_losses: f32) -> Financial {
self.operating_gains_losses = Some(operating_gains_losses);
self
}
pub fn operating_gains_losses(&self) -> Option<&f32> {
self.operating_gains_losses.as_ref()
}
pub fn reset_operating_gains_losses(&mut self) {
self.operating_gains_losses = None;
}
}