//! `SeaORM` Entity, @generated by sea-orm-codegen 2.0
use sea_orm::entity::prelude::*;
use serde::{Deserialize, Serialize};
#[derive(Clone, Debug, PartialEq, Eq, DeriveEntityModel, Serialize, Deserialize)]
#[sea_orm(table_name = "user_credits")]
pub struct Model {
#[sea_orm(primary_key)]
#[serde(skip_deserializing)]
pub id: i64,
#[sea_orm(unique_key = "idx_user_credits_user_currency_id")]
pub user_id: i64,
pub user_name: Option<String>,
pub total_credits: Option<Decimal>,
pub freezed_credits: Option<Decimal>,
pub rule_name: Option<String>,
pub rule_start_time: Option<DateTime>,
pub rule_end_time: Option<DateTime>,
pub created_at: Option<DateTimeWithTimeZone>,
pub updated_at: Option<DateTimeWithTimeZone>,
pub user_type: Option<String>,
#[sea_orm(column_type = "Decimal(Some((12, 2)))", nullable)]
pub withdrawable_credits: Option<Decimal>,
#[sea_orm(column_type = "Decimal(Some((12, 2)))", nullable)]
pub total_frozen_limit: Option<Decimal>,
#[sea_orm(column_type = "Decimal(Some((12, 2)))", nullable)]
pub total_withd_credits: Option<Decimal>,
#[sea_orm(column_type = "Decimal(Some((12, 2)))", nullable)]
pub total_income_pending: Option<Decimal>,
#[sea_orm(column_type = "Decimal(Some((12, 2)))", nullable)]
pub margin: Option<Decimal>,
pub deleted_at: Option<DateTimeWithTimeZone>,
pub reward_amount: Option<Decimal>,
pub plan_apply_count: Option<i32>,
pub plan_finished_count: i32,
pub recharge_amount: Decimal,
pub consume_amount: Decimal,
#[sea_orm(unique_key = "idx_user_credits_user_currency_id")]
pub currency_id: i32,
pub punishment_amount: Option<Decimal>,
pub total_points: Option<Decimal>,
pub lock_flag: Option<bool>,
pub lock_expire: Option<DateTimeWithTimeZone>,
#[sea_orm(column_type = "Decimal(Some((14, 2)))", nullable)]
pub total_refund: Option<Decimal>,
pub frozen_refund: Option<Decimal>,
pub opc_id: i64,
pub pay_gateway: Option<i32>,
pub train_duration: Option<i64>,
pub test_flag: Option<bool>,
pub train_count: Option<i32>,
pub student_income: Option<Decimal>,
}
#[derive(Copy, Clone, Debug, EnumIter, DeriveRelation)]
pub enum Relation {}
impl ActiveModelBehavior for ActiveModel {}
#[tokio::test]
async fn test_05_find_bean_datasourcee_postgres() {
let mut req = PageDb::default();
req.set_datasource_postgres();
req.order_by_asc("id");
let pageret = req.query_model::<user_credits::Entity>().await;
rulog::info1(pageret);
rulog::info1(req);
}
结果：
use crate::prelude::{json_utils, };
use crate::rubase::{baseconst, BaseEntity};
use crate::rupage::page::page_result::PageResult;
use crate::rupage::pagemodel::PageRequest;
use crate::{database, };
use sea_orm::{DatabaseConnection, DynIden, EntityTrait, FromQueryResult, Order, PaginatorTrait, };
use serde::Serialize;
use crate::rupage::page::pageparam::order_bys::OrderBys;
#[derive(Debug)]
pub struct PageDb {
pub connection: Option<DatabaseConnection>,
pub table: String,
page: PageRequest<String>,
datasource: String,
order_bys: Vec< OrderBys>,
}
impl BaseEntity for PageDb {}
impl PageDb {
pub fn default() -> Self {
let mut s = Self {
connection: None,
table: String::new(),
page: PageRequest::<String>::default(),
datasource: "datasource".to_string(),
order_bys: vec![],
};
s.page.default_page();
// 找当前线程已有的 runtime handle 来 block_on
//Handle::current().block_on(s.init()); // ⚠️ 必须在 tokio runtime 上下文里
s
}
pub async fn init(&mut self) {
if self.connection.is_none() {
self.get_conn().await;
}
}
pub fn order_by(&mut self,field:&str,direction: Order ) {
self.order_bys.push(OrderBys{
field: field.to_string(),
order: direction ,
});
}
pub fn order_by_asc(&mut self,field:&str ) {
self.order_bys.push(OrderBys{
field: field.to_string(),
order: Order::Asc,
});
}
pub fn order_by_desc(&mut self,field:&str ) {
self.order_bys.push(OrderBys {
field: field.to_string(),
order: Order::Desc,
});
}
pub fn set_datasource(&mut self, datasource: &str) {
self.datasource = datasource.to_string();
}
pub fn set_datasource_mysql(&mut self ) {
self.datasource = baseconst::DB_TYPE_MYSQL.to_string();
}
pub fn set_datasource_postgres(&mut self ) {
self.datasource = baseconst::DB_TYPE_POSTGRES.to_string();
}
pub async fn get_conn(&mut self) -> DatabaseConnection {
if self.datasource==baseconst::DB_TYPE_MYSQL{
return database::find_bean_database().unwrap().create_conn_mysql().await
// self.connection = Some(db);
}
if self.datasource==baseconst::DB_TYPE_POSTGRES{
return database::find_bean_database().unwrap().create_conn_postgres().await
// self.connection = Some(db);
}
database::find_bean_database().unwrap().create_conn().await
// self.connection = Some(db);
}
// page_db.rs 第 39 行起
pub async fn query_model<E>(&mut self) -> PageResult
where
E: EntityTrait,
E::Model: Serialize + FromQueryResult + Send + Sync,
{
let mut page_ret = PageResult::new();
let db= self.get_conn().await;
// ✅ 这里换 E::find()，其他全不动
let mut select = E::find();//
for key in self.order_bys.iter() {
//select = select.order_by(Expr::col(DynIden::from(&key.field)), key.order );
}
let page=select.paginate(&db, self.page.PageSize);
let ret = page.num_items_and_pages().await;
if ret.is_ok() {
let cnt = ret.unwrap();
page_ret.total = cnt.number_of_items;
page_ret.total_pages = cnt.number_of_pages;
page_ret.page_size = self.page.PageSize;
page_ret.page_current = self.page.PageCurrent;
}else{
let err = ret.unwrap_err();
page_ret.fail(err.to_string());
}
let p = page.fetch_page(self.page.PageCurrent).await;
if p.is_err() {
let err = p.unwrap_err();
page_ret.fail(err.to_string());
} else {
page_ret.data = Some(json_utils::struct2json(&p.unwrap()).unwrap());
}
page_ret
}
}
use std::time::Duration;
use crate::rubase::BaseEntitySingle;
use crate::rubase::get_self::GetSelf;
use crate::rubase::rudto::Gorm;
use crate::rubase::rudto::confdto::DataSource;
use crate::{ruconf, rulog};
use postgres::Client;
use sea_orm::{ConnectOptions, DatabaseConnection};
use serde::{Deserialize, Serialize};
use tokio_postgres::NoTls;
#[derive(Debug, Default, Serialize, Deserialize, Clone)]
pub struct Database {
pub gorm: Gorm,
pub datasource: DataSource,
pub mysql: DataSource,
pub postgres: DataSource,
}
impl BaseEntitySingle for Database {}
impl GetSelf for Database {}
impl Database {
pub fn new() -> Self {
let config = ruconf::find_bean_ru_config().unwrap() ;
Database {
gorm: config.read_gorm() ,
datasource: config.find_datasource() ,
mysql: config.read_mysql() ,
postgres: config.read_postgres() ,
}
}
pub fn conn(&self) -> Result<Client, postgres::Error> {
let client = Client::connect(
self.datasource.buildUrl().to_string().as_str(),
NoTls, // 如果需要 TLS 可换成 openssl 等
)?;
Ok(client)
}
pub async fn create_conn(&self) -> DatabaseConnection {
let mut opt = ConnectOptions::new(
self.datasource.buildUrl_orm().as_str()
);
opt.max_connections(100)
.min_connections(5)
.connect_timeout(Duration::from_secs(8))
.idle_timeout(Duration::from_secs(8))
.sqlx_logging(true);
//rulog::info2("establish_connection", self.datasource.buildUrl_orm().as_str());
sea_orm::Database::connect(opt).await.expect("数据库连接失败")
}
pub async fn create_conn_mysql(&self) -> DatabaseConnection {
let mut opt = ConnectOptions::new(
self.mysql.buildUrl_orm().as_str()
);
opt.max_connections(100)
.min_connections(5)
.connect_timeout(Duration::from_secs(8))
.idle_timeout(Duration::from_secs(8))
.sqlx_logging(true);
//rulog::info2("establish_connection", self.datasource.buildUrl_orm().as_str());
sea_orm::Database::connect(opt).await.expect("数据库连接失败")
}
pub async fn create_conn_postgres(&self) -> DatabaseConnection {
let mut opt = ConnectOptions::new(
self.postgres.buildUrl_orm().as_str()
);
opt.max_connections(100)
.min_connections(5)
.connect_timeout(Duration::from_secs(8))
.idle_timeout(Duration::from_secs(8))
.sqlx_logging(true);
//rulog::info2("establish_connection", self.datasource.buildUrl_orm().as_str());
sea_orm::Database::connect(opt).await.expect("数据库连接失败")
}
}
