repo stringlengths 6 65 | file_url stringlengths 81 311 | file_path stringlengths 6 227 | content stringlengths 0 32.8k | language stringclasses 1
value | license stringclasses 7
values | commit_sha stringlengths 40 40 | retrieved_at stringdate 2026-01-04 15:31:58 2026-01-04 20:25:31 | truncated bool 2
classes |
|---|---|---|---|---|---|---|---|---|
vertexclique/lever | https://github.com/vertexclique/lever/blob/690d85eb4790caed0bb2c11faf2b2e3e526bbf09/src/sync/ttas.rs | src/sync/ttas.rs | use super::ifaces::LockIface;
use std::fmt;
use std::{
cell::UnsafeCell,
hint::spin_loop,
sync::atomic::{AtomicBool, Ordering},
};
use std::{
marker::PhantomData as marker,
ops::{Deref, DerefMut},
thread::ThreadId,
time::{Duration, Instant},
};
pub struct TTasGuard<'a, T: ?Sized> {
mutex: &'a TTas<T>,
marker: marker<&'a mut T>,
}
impl<'a, T: ?Sized + 'a> Deref for TTasGuard<'a, T> {
type Target = T;
#[inline]
fn deref(&self) -> &T {
unsafe { &*self.mutex.data.get() }
}
}
impl<'a, T: ?Sized + 'a> DerefMut for TTasGuard<'a, T> {
#[inline]
fn deref_mut(&mut self) -> &mut T {
unsafe { &mut *self.mutex.data.get() }
}
}
impl<'a, T: ?Sized + 'a> Drop for TTasGuard<'a, T> {
#[inline]
fn drop(&mut self) {
self.mutex.unlock();
}
}
impl<'a, T: fmt::Debug + ?Sized + 'a> fmt::Debug for TTasGuard<'a, T> {
fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
fmt::Debug::fmt(&**self, f)
}
}
impl<'a, T: fmt::Display + ?Sized + 'a> fmt::Display for TTasGuard<'a, T> {
fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
(**self).fmt(f)
}
}
pub struct TTas<T>
where
T: ?Sized,
{
tid: ThreadId,
acquired: AtomicBool,
data: UnsafeCell<T>,
}
impl<T> TTas<T> {
#[inline]
pub fn new(data: T) -> Self {
Self {
tid: std::thread::current().id(),
acquired: AtomicBool::default(),
data: UnsafeCell::new(data),
}
}
#[inline]
pub fn into_inner(self) -> T {
self.data.into_inner()
}
#[inline]
pub fn get_mut(&mut self) -> &mut T {
unsafe { &mut *self.data.get() }
}
#[inline]
unsafe fn guard(&self) -> TTasGuard<'_, T> {
TTasGuard {
mutex: self,
marker,
}
}
#[inline]
pub fn lock(&self) -> TTasGuard<'_, T> {
// TODO: dispatch directly
<Self as LockIface>::lock(self);
// SAFETY: The lock is held, as required.
unsafe { self.guard() }
}
#[inline]
pub fn try_lock(&self) -> Option<TTasGuard<'_, T>> {
if <Self as LockIface>::try_lock(self) {
// SAFETY: The lock is held, as required.
Some(unsafe { self.guard() })
} else {
None
}
}
#[inline]
pub unsafe fn force_unlock(&self) {
<Self as LockIface>::unlock(&self);
}
#[inline]
pub fn try_write_lock_for(&self, timeout: Duration) -> Option<TTasGuard<'_, T>> {
let deadline = Instant::now()
.checked_add(timeout)
.expect("Deadline can't fit in");
loop {
if Instant::now() < deadline {
match self.try_lock() {
Some(guard) => {
break Some(guard);
}
_ => {
std::thread::sleep(timeout / 10);
std::thread::yield_now()
}
};
} else {
break None;
}
}
}
#[inline]
pub fn is_current(&self) -> bool {
std::thread::current().id() == self.tid
}
}
unsafe impl<T: ?Sized + Send> Send for TTas<T> {}
unsafe impl<T: ?Sized + Send> Sync for TTas<T> {}
unsafe impl<T> LockIface for TTas<T>
where
T: ?Sized,
{
#[inline]
fn lock(&self) {
'lock: loop {
while let Some(true) = Some(self.acquired.load(Ordering::SeqCst)) {
spin_loop();
}
if !self.acquired.swap(true, Ordering::SeqCst) {
break 'lock;
}
}
}
#[inline]
fn try_lock(&self) -> bool {
self.acquired
.compare_exchange_weak(false, true, Ordering::Acquire, Ordering::Relaxed)
.is_ok()
}
#[inline]
fn is_locked(&self) -> bool {
self.acquired.load(Ordering::Acquire)
}
#[inline]
fn unlock(&self) {
self.acquired.store(false, Ordering::Release);
}
#[inline]
fn try_unlock(&self) -> bool {
self.acquired
.compare_exchange_weak(true, false, Ordering::Acquire, Ordering::Relaxed)
.is_ok()
}
}
#[cfg(test)]
mod test_ttas {
use super::*;
#[test]
fn ttas_create_and_lock() {
let ttas = TTas::new(42);
let data = ttas.try_lock();
assert!(data.is_some());
assert_eq!(*data.unwrap(), 42);
}
#[test]
fn mutual_exclusion() {
let ttas = TTas::new(1);
let data = ttas.try_lock();
assert!(data.is_some());
assert!(ttas.try_lock().is_none());
assert!(ttas.try_lock().is_none());
core::mem::drop(data);
assert!(ttas.try_lock().is_some());
}
#[test]
fn three_locks() {
let ttas1 = TTas::new(1);
let ttas2 = TTas::new(2);
let ttas3 = TTas::new(3);
let data1 = ttas1.try_lock();
let data2 = ttas2.try_lock();
let data3 = ttas3.try_lock();
assert!(data1.is_some());
assert!(data2.is_some());
assert!(data3.is_some());
assert!(ttas1.try_lock().is_none());
assert!(ttas1.try_lock().is_none());
assert!(ttas2.try_lock().is_none());
assert!(ttas2.try_lock().is_none());
assert!(ttas3.try_lock().is_none());
assert!(ttas3.try_lock().is_none());
core::mem::drop(data3);
assert!(ttas3.try_lock().is_some());
}
}
| rust | Apache-2.0 | 690d85eb4790caed0bb2c11faf2b2e3e526bbf09 | 2026-01-04T20:21:42.422655Z | false |
vertexclique/lever | https://github.com/vertexclique/lever/blob/690d85eb4790caed0bb2c11faf2b2e3e526bbf09/tests/atomics.rs | tests/atomics.rs | #[test]
fn atomic_box_data_race_regression_test() {
let t = trybuild::TestCases::new();
t.compile_fail("tests/samples/atomic_box_data_race.rs");
}
| rust | Apache-2.0 | 690d85eb4790caed0bb2c11faf2b2e3e526bbf09 | 2026-01-04T20:21:42.422655Z | false |
vertexclique/lever | https://github.com/vertexclique/lever/blob/690d85eb4790caed0bb2c11faf2b2e3e526bbf09/tests/lotable_cc.rs | tests/lotable_cc.rs | use lever::table::prelude::*;
use std::sync::Arc;
#[test]
fn lotable_concurrent() {
let lotable = {
let table: LOTable<String, u64> = LOTable::new();
table.insert("data".into(), 1_u64);
Arc::new(table)
};
let mut threads = vec![];
for thread_no in 0..100 {
let lotable = lotable.clone();
let t = std::thread::Builder::new()
.name(format!("t_{}", thread_no))
.spawn(move || {
if thread_no % 2 == 0 {
// Reader threads
let _data = lotable.get(&"data".to_string());
} else {
// Writer threads
let data = lotable.get(&"data".to_string()).unwrap();
lotable.insert("data".into(), data + 1);
}
})
.unwrap();
threads.push(t);
}
for t in threads.into_iter() {
t.join().unwrap();
}
}
| rust | Apache-2.0 | 690d85eb4790caed0bb2c11faf2b2e3e526bbf09 | 2026-01-04T20:21:42.422655Z | false |
vertexclique/lever | https://github.com/vertexclique/lever/blob/690d85eb4790caed0bb2c11faf2b2e3e526bbf09/tests/samples/atomic_box_data_race.rs | tests/samples/atomic_box_data_race.rs | use lever::sync::atomics::AtomicBox;
use crossbeam_utils::thread;
use std::cell::Cell;
#[derive(Debug, Clone, Copy)]
enum RefOrInt<'a> {
Ref(&'a u64),
Int(u64),
}
static SOME_INT: u64 = 123;
// https://github.com/vertexclique/lever/issues/15#issue-740069651
// Run this one in release mode for it to fail
fn main() {
let cell = Cell::new(RefOrInt::Ref(&SOME_INT));
let atomic_box = AtomicBox::new(&cell);
thread::scope(|s| {
s.spawn(move |_| {
let smuggled_cell = atomic_box.get();
loop {
// Repeatedly write Ref(&addr) and Int(0xdeadbeef) into the cell.
smuggled_cell.set(RefOrInt::Ref(&SOME_INT));
smuggled_cell.set(RefOrInt::Int(0xdeadbeef));
}
});
loop {
if let RefOrInt::Ref(addr) = cell.get() {
// Hope that between the time we pattern match the object as a
// `Ref`, it gets written to by the other thread.
if addr as *const u64 == &SOME_INT as *const u64 {
continue;
}
// Due to the data race, obtaining Ref(0xdeadbeef) is possible
println!("Pointer is now: {:p}", addr);
println!("Dereferencing addr will now segfault: {}", *addr);
}
}
});
}
| rust | Apache-2.0 | 690d85eb4790caed0bb2c11faf2b2e3e526bbf09 | 2026-01-04T20:21:42.422655Z | false |
vertexclique/lever | https://github.com/vertexclique/lever/blob/690d85eb4790caed0bb2c11faf2b2e3e526bbf09/benches/read_parameterized_benches.rs | benches/read_parameterized_benches.rs | use criterion::{criterion_group, criterion_main, BenchmarkId, Criterion, Throughput};
use lever::table::prelude::*;
use std::sync::Arc;
const MAX_THREADS: usize = 8;
const OP_RANGES: &'static [usize] = &[100, 300, 500, 700, 1000, 3000, 5000];
fn pure_read(lotable: Arc<LOTable<String, u64>>, key: String, op_count: usize) {
(0..op_count).into_iter().for_each(|_| {
let _ = lotable.get(&key);
})
}
fn bench_pure_reads(c: &mut Criterion) {
let lotable: Arc<LOTable<String, u64>> = Arc::new(LOTable::new());
let key: String = "CORE".into();
let _ = lotable.insert(key.clone(), 123_456);
let mut group = c.benchmark_group("parameterized_read");
(1..MAX_THREADS).for_each(|tid| {
for ops in OP_RANGES {
group.throughput(Throughput::Elements((tid * *ops) as u64));
group.bench_with_input(BenchmarkId::new(format!("{}", tid), ops), ops, |b, &i| {
let pool = rayon::ThreadPoolBuilder::new()
.num_threads(tid)
.build()
.unwrap();
pool.install(|| b.iter(|| pure_read(lotable.clone(), key.clone(), i)));
});
}
});
}
////////////////////////////////
//
// fn rw_pareto(lotable: Arc<LOTable<String, u64>>, key: String, dist: f64, thread_count: u64) {
// let mut threads = vec![];
//
// for thread_no in 0..thread_count {
// let lotable = lotable.clone();
// let key = key.clone();
//
// let t = std::thread::Builder::new()
// .name(format!("t_{}", thread_no))
// .spawn(move || {
// if dist < 0.8_f64 {
// lotable.get(&key);
// } else {
// let data = lotable.get(&key).unwrap();
// let _ = lotable.insert(key, data + 1);
// }
// })
// .unwrap();
//
// threads.push(t);
// }
//
// for t in threads.into_iter() {
// t.join().unwrap();
// }
// }
//
// fn bench_rw_pareto(c: &mut Criterion) {
// let lotable = {
// let table: LOTable<String, u64> = LOTable::new();
// table.insert("data".into(), 1_u64);
// Arc::new(table)
// };
// let key: String = "CORE".into();
// let _ = lotable.insert(key.clone(), 123_456);
//
// let threads = 8;
//
// let mut group = c.benchmark_group("lotable_threaded_join_rw_pareto_throughput");
// group.throughput(Throughput::Elements(threads as u64));
// group.bench_function("rw_pareto", move |b| {
// b.iter_batched(
// || {
// let dist: f64 =
// 1. / thread_rng().sample(Pareto::new(1., 5.0_f64.log(4.0_f64)).unwrap());
// (lotable.clone(), key.clone(), dist)
// },
// |vars| rw_pareto(vars.0, vars.1, vars.2, threads),
// BatchSize::SmallInput,
// )
// });
// }
//
// ////////////////////////////////
//
// fn pure_writes(lotable: Arc<LOTable<String, u64>>, key: String, thread_count: u64) {
// let mut threads = vec![];
//
// for thread_no in 0..thread_count {
// let lotable = lotable.clone();
// let key = key.clone();
//
// let t = std::thread::Builder::new()
// .name(format!("t_{}", thread_no))
// .spawn(move || {
// let _ = lotable.insert(key, thread_no);
// })
// .unwrap();
//
// threads.push(t);
// }
//
// for t in threads.into_iter() {
// t.join().unwrap();
// }
// }
//
// fn bench_lotable_pure_writes(c: &mut Criterion) {
// let lotable = {
// let table: LOTable<String, u64> = LOTable::new();
// table.insert("data".into(), 1_u64);
// Arc::new(table)
// };
// let key: String = "CORE".into();
// let _ = lotable.insert(key.clone(), 123_456);
//
// let threads = 8;
//
// let mut group = c.benchmark_group("lotable_threaded_join_write_throughput");
// group.throughput(Throughput::Elements(threads as u64));
// group.bench_function("pure writes", move |b| {
// b.iter_batched(
// || (lotable.clone(), key.clone()),
// |vars| pure_writes(vars.0, vars.1, threads),
// BatchSize::SmallInput,
// )
// });
// }
criterion_group! {
name = parameterized_benches;
config = Criterion::default();
targets = bench_pure_reads
// targets = bench_pure_reads, bench_rw_pareto, bench_lotable_pure_writes
}
criterion_main!(parameterized_benches);
| rust | Apache-2.0 | 690d85eb4790caed0bb2c11faf2b2e3e526bbf09 | 2026-01-04T20:21:42.422655Z | false |
vertexclique/lever | https://github.com/vertexclique/lever/blob/690d85eb4790caed0bb2c11faf2b2e3e526bbf09/benches/arc_rwlock_benches.rs | benches/arc_rwlock_benches.rs | use criterion::{criterion_group, criterion_main, BatchSize, Criterion, Throughput};
use rand::prelude::*;
use rand_distr::Pareto;
use std::collections::HashMap;
use std::sync::{Arc, RwLock};
fn pure_read(lotable: Arc<RwLock<HashMap<String, u64>>>, key: String, thread_count: u64) {
let mut threads = vec![];
for thread_no in 0..thread_count {
let lotable = lotable.clone();
let key = key.clone();
let t = std::thread::Builder::new()
.name(format!("t_{}", thread_no))
.spawn(move || {
let loguard = lotable.read().unwrap();
loguard.get(&key);
// if let Ok(loguard) = lotable.read() {
// loguard.get(&key);
// }
})
.unwrap();
threads.push(t);
}
for t in threads.into_iter() {
t.join().unwrap();
}
}
fn bench_arc_rwlock_pure_reads(c: &mut Criterion) {
let lotable = {
let mut table: HashMap<String, u64> = HashMap::new();
table.insert("data".into(), 1_u64);
Arc::new(RwLock::new(table))
};
let key: String = "CORE".into();
let threads = 8;
let mut group = c.benchmark_group("arc_rwlock_read_throughput");
group.throughput(Throughput::Elements(threads as u64));
group.bench_function("pure reads", move |b| {
b.iter_batched(
|| (lotable.clone(), key.clone()),
|vars| pure_read(vars.0, vars.1, threads),
BatchSize::SmallInput,
)
});
}
////////////////////////////////
fn rw_pareto(
lotable: Arc<RwLock<HashMap<String, u64>>>,
key: String,
dist: f64,
thread_count: u64,
) {
let mut threads = vec![];
for thread_no in 0..thread_count {
let lotable = lotable.clone();
let key = key.clone();
let t = std::thread::Builder::new()
.name(format!("t_{}", thread_no))
.spawn(move || {
if dist < 0.8_f64 {
let loguard = lotable.read().unwrap();
loguard.get(&key);
// if let Ok(loguard) = lotable.read() {
// loguard.get(&key);
// }
} else {
let loguard = lotable.read().unwrap();
let data: u64 = *loguard.get(&key).unwrap();
// if let Ok(loguard) = lotable.read() {
// if let Some(datac) = loguard.get(&key) {
// data = *datac;
// }
// }
let mut loguard = lotable.write().unwrap();
loguard.insert(key, data + 1);
// if let Ok(mut loguard) = lotable.write() {
// loguard.insert(key, data + 1);
// }
}
})
.unwrap();
threads.push(t);
}
for t in threads.into_iter() {
t.join().unwrap();
}
}
fn bench_arc_rwlock_rw_pareto(c: &mut Criterion) {
let lotable = {
let mut table: HashMap<String, u64> = HashMap::new();
table.insert("data".into(), 1_u64);
Arc::new(RwLock::new(table))
};
let key: String = "CORE".into();
let threads = 8;
let mut group = c.benchmark_group("arc_rwlock_rw_pareto_throughput");
group.throughput(Throughput::Elements(threads as u64));
group.bench_function("rw_pareto", move |b| {
b.iter_batched(
|| {
let dist: f64 =
1. / thread_rng().sample(Pareto::new(1., 5.0_f64.log(4.0_f64)).unwrap());
(lotable.clone(), key.clone(), dist)
},
|vars| rw_pareto(vars.0, vars.1, vars.2, threads),
BatchSize::SmallInput,
)
});
}
////////////////////////////////
fn pure_writes(lotable: Arc<RwLock<HashMap<String, u64>>>, key: String, thread_count: u64) {
let mut threads = vec![];
for thread_no in 0..thread_count {
let lotable = lotable.clone();
let key = key.clone();
let t = std::thread::Builder::new()
.name(format!("t_{}", thread_no))
.spawn(move || {
if let Ok(mut loguard) = lotable.write() {
loguard.insert(key, thread_no);
}
})
.unwrap();
threads.push(t);
}
for t in threads.into_iter() {
t.join().unwrap();
}
}
fn bench_arc_rwlock_pure_writes(c: &mut Criterion) {
let lotable = {
let mut table: HashMap<String, u64> = HashMap::new();
table.insert("data".into(), 1_u64);
Arc::new(RwLock::new(table))
};
let key: String = "CORE".into();
let threads = 8;
let mut group = c.benchmark_group("arc_rwlock_write_throughput");
group.throughput(Throughput::Elements(threads as u64));
group.bench_function("pure writes", move |b| {
b.iter_batched(
|| (lotable.clone(), key.clone()),
|vars| pure_writes(vars.0, vars.1, threads),
BatchSize::SmallInput,
)
});
}
criterion_group! {
name = arc_rwlock_benches;
config = Criterion::default();
targets = bench_arc_rwlock_pure_reads, bench_arc_rwlock_rw_pareto, bench_arc_rwlock_pure_writes
}
criterion_main!(arc_rwlock_benches);
| rust | Apache-2.0 | 690d85eb4790caed0bb2c11faf2b2e3e526bbf09 | 2026-01-04T20:21:42.422655Z | false |
vertexclique/lever | https://github.com/vertexclique/lever/blob/690d85eb4790caed0bb2c11faf2b2e3e526bbf09/benches/zonemap_benches.rs | benches/zonemap_benches.rs | use criterion::{criterion_group, criterion_main, BatchSize, BenchmarkId, Criterion, Throughput};
use lever::index::zonemap::ZoneMap;
fn bench_zonemap_selected(c: &mut Criterion) {
c.bench_function("bench_unoptimized", move |b| {
b.iter_batched(
|| {
let customers: Vec<i32> =
vec![vec![1, 0, -1, -2].repeat(500), vec![1, 2, 3, 4].repeat(250)].concat();
let ingestion_data = vec![("customers", customers.as_slice())];
(ZoneMap::from(ingestion_data), customers)
},
|(zm, customers)| {
let (l, r) = zm.scan_range("customers", 4, 4, &*customers);
customers[l..=r].iter().filter(|x| **x >= 4).sum::<i32>()
},
BatchSize::LargeInput,
)
});
}
fn bench_unoptimized(c: &mut Criterion) {
c.bench_function("bench_zonemap_selected", move |b| {
b.iter_batched(
|| {
let customers: Vec<i32> =
vec![vec![1, 0, -1, -2].repeat(500), vec![1, 2, 3, 4].repeat(250)].concat();
let _ingestion_data = vec![("customers", customers.as_slice())];
customers
},
|data| {
data.as_slice()
.into_iter()
.filter(|x| **x >= 4)
.sum::<i32>()
},
BatchSize::LargeInput,
)
});
}
criterion_group! {
name = zonemap_benches;
config = Criterion::default();
targets = bench_zonemap_selected, bench_unoptimized
}
criterion_main!(zonemap_benches);
| rust | Apache-2.0 | 690d85eb4790caed0bb2c11faf2b2e3e526bbf09 | 2026-01-04T20:21:42.422655Z | false |
vertexclique/lever | https://github.com/vertexclique/lever/blob/690d85eb4790caed0bb2c11faf2b2e3e526bbf09/benches/lotable_iter_benches.rs | benches/lotable_iter_benches.rs | use criterion::{criterion_group, criterion_main, BatchSize, Criterion, Throughput};
use lever::table::prelude::*;
use rand::prelude::*;
use rand_distr::Pareto;
use rayon::prelude::*;
use std::sync::Arc;
const BATCH_SIZE: usize = 50;
fn pure_read(lotable: Arc<LOTable<String, u64>>, key: String) {
(0..BATCH_SIZE).into_par_iter().for_each(|_| {
lotable.get(&key.clone());
});
}
fn bench_lotable_pure_reads(c: &mut Criterion) {
let lotable = {
let table: LOTable<String, u64> = LOTable::new();
let _ = table.insert("data".into(), 1_u64);
Arc::new(table)
};
let key: String = "CORE".into();
let _ = lotable.insert(key.clone(), 123_456);
let mut group = c.benchmark_group("lotable_iter_read_throughput");
group.throughput(Throughput::Elements(BATCH_SIZE as u64));
group.bench_function("pure reads", move |b| {
b.iter_batched(
|| (lotable.clone(), key.clone()),
|vars| pure_read(vars.0, vars.1),
BatchSize::SmallInput,
)
});
}
fn rw_pareto(lotable: Arc<LOTable<String, u64>>, key: String, dist: f64) {
(0..BATCH_SIZE).into_par_iter().for_each(|_| {
if dist < 0.8_f64 {
lotable.get(&key.clone());
} else {
let data = lotable.get(&key).unwrap();
let _ = lotable.insert(key.clone(), data + 1);
}
});
}
fn bench_lotable_rw_pareto(c: &mut Criterion) {
let lotable = {
let table: LOTable<String, u64> = LOTable::new();
let _ = table.insert("data".into(), 1_u64);
Arc::new(table)
};
let key: String = "CORE".into();
let _ = lotable.insert(key.clone(), 123_456);
let mut group = c.benchmark_group("lotable_iter_rw_pareto_throughput");
group.throughput(Throughput::Elements(BATCH_SIZE as u64));
group.bench_function("rw_pareto", move |b| {
b.iter_batched(
|| {
let dist: f64 =
1. / thread_rng().sample(Pareto::new(1., 5.0_f64.log(4.0_f64)).unwrap());
(lotable.clone(), key.clone(), dist)
},
|vars| rw_pareto(vars.0, vars.1, vars.2),
BatchSize::SmallInput,
)
});
}
////////////////////////////////
fn pure_writes(lotable: Arc<LOTable<String, u64>>, key: String) {
(0..BATCH_SIZE).into_par_iter().for_each(|i| {
let _ = lotable.insert(key.clone(), i as u64);
});
}
fn bench_lotable_pure_writes(c: &mut Criterion) {
let lotable = {
let table: LOTable<String, u64> = LOTable::new();
let _ = table.insert("data".into(), 1_u64);
Arc::new(table)
};
let key: String = "CORE".into();
let _ = lotable.insert(key.clone(), 123_456);
let mut group = c.benchmark_group("lotable_iter_write_throughput");
group.throughput(Throughput::Elements(BATCH_SIZE as u64));
group.bench_function("pure writes", move |b| {
b.iter_batched(
|| (lotable.clone(), key.clone()),
|vars| pure_writes(vars.0, vars.1),
BatchSize::SmallInput,
)
});
}
criterion_group! {
name = lotable_iter_benches;
config = Criterion::default();
targets = bench_lotable_pure_reads, bench_lotable_rw_pareto, bench_lotable_pure_writes
}
criterion_main!(lotable_iter_benches);
| rust | Apache-2.0 | 690d85eb4790caed0bb2c11faf2b2e3e526bbf09 | 2026-01-04T20:21:42.422655Z | false |
vertexclique/lever | https://github.com/vertexclique/lever/blob/690d85eb4790caed0bb2c11faf2b2e3e526bbf09/benches/lotable_threaded_join_benches.rs | benches/lotable_threaded_join_benches.rs | use criterion::{criterion_group, criterion_main, BatchSize, Criterion, Throughput};
use lever::table::prelude::*;
use rand::prelude::*;
use rand_distr::Pareto;
use std::sync::Arc;
fn pure_read(lotable: Arc<LOTable<String, u64>>, key: String, thread_count: u64) {
let mut threads = vec![];
for thread_no in 0..thread_count {
let lotable = lotable.clone();
let key = key.clone();
let t = std::thread::Builder::new()
.name(format!("t_{}", thread_no))
.spawn(move || lotable.get(&key))
.unwrap();
threads.push(t);
}
for t in threads.into_iter() {
t.join().unwrap();
}
}
fn bench_lotable_pure_reads(c: &mut Criterion) {
let lotable = {
let table: LOTable<String, u64> = LOTable::new();
let _ = table.insert("data".into(), 1_u64);
Arc::new(table)
};
let key: String = "CORE".into();
let _ = lotable.insert(key.clone(), 123_456);
let threads = 8;
let mut group = c.benchmark_group("lotable_threaded_join_read_throughput");
group.throughput(Throughput::Elements(threads as u64));
group.bench_function("pure reads", move |b| {
b.iter_batched(
|| (lotable.clone(), key.clone()),
|vars| pure_read(vars.0, vars.1, threads),
BatchSize::SmallInput,
)
});
}
////////////////////////////////
fn rw_pareto(lotable: Arc<LOTable<String, u64>>, key: String, dist: f64, thread_count: u64) {
let mut threads = vec![];
for thread_no in 0..thread_count {
let lotable = lotable.clone();
let key = key.clone();
let t = std::thread::Builder::new()
.name(format!("t_{}", thread_no))
.spawn(move || {
if dist < 0.8_f64 {
lotable.get(&key);
} else {
let data = lotable.get(&key).unwrap();
let _ = lotable.insert(key, data + 1);
}
})
.unwrap();
threads.push(t);
}
for t in threads.into_iter() {
t.join().unwrap();
}
}
fn bench_lotable_rw_pareto(c: &mut Criterion) {
let lotable = {
let table: LOTable<String, u64> = LOTable::new();
let _ = table.insert("data".into(), 1_u64);
Arc::new(table)
};
let key: String = "CORE".into();
let _ = lotable.insert(key.clone(), 123_456);
let threads = 8;
let mut group = c.benchmark_group("lotable_threaded_join_rw_pareto_throughput");
group.throughput(Throughput::Elements(threads as u64));
group.bench_function("rw_pareto", move |b| {
b.iter_batched(
|| {
let dist: f64 =
1. / thread_rng().sample(Pareto::new(1., 5.0_f64.log(4.0_f64)).unwrap());
(lotable.clone(), key.clone(), dist)
},
|vars| rw_pareto(vars.0, vars.1, vars.2, threads),
BatchSize::SmallInput,
)
});
}
////////////////////////////////
fn pure_writes(lotable: Arc<LOTable<String, u64>>, key: String, thread_count: u64) {
let mut threads = vec![];
for thread_no in 0..thread_count {
let lotable = lotable.clone();
let key = key.clone();
let t = std::thread::Builder::new()
.name(format!("t_{}", thread_no))
.spawn(move || {
let _ = lotable.insert(key, thread_no);
})
.unwrap();
threads.push(t);
}
for t in threads.into_iter() {
t.join().unwrap();
}
}
fn bench_lotable_pure_writes(c: &mut Criterion) {
let lotable = {
let table: LOTable<String, u64> = LOTable::new();
let _ = table.insert("data".into(), 1_u64);
Arc::new(table)
};
let key: String = "CORE".into();
let _ = lotable.insert(key.clone(), 123_456);
let threads = 8;
let mut group = c.benchmark_group("lotable_threaded_join_write_throughput");
group.throughput(Throughput::Elements(threads as u64));
group.bench_function("pure writes", move |b| {
b.iter_batched(
|| (lotable.clone(), key.clone()),
|vars| pure_writes(vars.0, vars.1, threads),
BatchSize::SmallInput,
)
});
}
criterion_group! {
name = lotable_threaded_join_benches;
config = Criterion::default();
targets = bench_lotable_pure_reads, bench_lotable_rw_pareto, bench_lotable_pure_writes
}
criterion_main!(lotable_threaded_join_benches);
| rust | Apache-2.0 | 690d85eb4790caed0bb2c11faf2b2e3e526bbf09 | 2026-01-04T20:21:42.422655Z | false |
vertexclique/lever | https://github.com/vertexclique/lever/blob/690d85eb4790caed0bb2c11faf2b2e3e526bbf09/benches/op_ser_benches.rs | benches/op_ser_benches.rs | use criterion::{criterion_group, criterion_main, BatchSize, Criterion};
use lever::table::ltable::LTable;
use lever::txn::prelude::*;
use rand::prelude::*;
use rand_distr::Pareto;
fn pure_read(txn: Txn, tvar: TVar<LTable<String, String>>) -> LTable<String, String> {
let res = txn.begin(|t: &mut Txn| t.read(&tvar));
res.unwrap()
}
fn bench_pure_reads(c: &mut Criterion) {
let mut ltable = LTable::<String, String>::create("pure_reads".to_owned());
ltable.insert("Interstellar".into(), "Gravity".into());
let txn = TxnManager::manager().txn_build(
TransactionConcurrency::Optimistic,
TransactionIsolation::Serializable,
100_usize,
1_usize,
"pure_reads".into(),
);
c.bench_function("pure_reads", move |b| {
b.iter_batched(
|| {
let tvar = TVar::new(ltable.clone());
tvar
},
|tvar| pure_read(txn.clone(), tvar),
BatchSize::SmallInput,
)
});
}
fn rw_pareto(txn: Txn, mut vars: (f64, TVar<LTable<String, String>>)) {
if vars.0 < 0.8_f64 {
txn.begin(|t: &mut Txn| {
t.read(&vars.1);
});
} else {
txn.begin(|t: &mut Txn| {
let mut x = t.read(&vars.1);
x.insert("RoboCop".into(), "Annihilation".into());
t.write(&mut vars.1, x.clone());
});
}
}
fn bench_rw_pareto(c: &mut Criterion) {
let mut ltable = LTable::<String, String>::create("rw_pareto".to_owned());
ltable.insert("Interstellar".into(), "Gravity".into());
let txn = TxnManager::manager().txn_build(
TransactionConcurrency::Optimistic,
TransactionIsolation::Serializable,
100_usize,
1_usize,
"rw_pareto".into(),
);
c.bench_function("rw_pareto", move |b| {
b.iter_batched(
|| {
let tvar = TVar::new(ltable.clone());
let dist: f64 =
1. / thread_rng().sample(Pareto::new(1., 5.0_f64.log(4.0_f64)).unwrap());
(dist, tvar)
},
|vars| rw_pareto(txn.clone(), vars),
BatchSize::SmallInput,
)
});
}
fn pure_write(txn: Txn, mut vars: TVar<LTable<String, String>>) {
txn.begin(|t: &mut Txn| {
let mut x = t.read(&vars);
x.insert("RoboCop".into(), "Annihilation".into());
t.write(&mut vars, x.clone());
});
}
fn bench_pure_write(c: &mut Criterion) {
let mut ltable = LTable::<String, String>::create("pure_writes".to_owned());
ltable.insert("Interstellar".into(), "Gravity".into());
let txn = TxnManager::manager().txn_build(
TransactionConcurrency::Optimistic,
TransactionIsolation::Serializable,
100_usize,
1_usize,
"pure_write".into(),
);
c.bench_function("pure_writes", move |b| {
b.iter_batched(
|| {
let tvar = TVar::new(ltable.clone());
tvar
},
|tvar| pure_write(txn.clone(), tvar),
BatchSize::SmallInput,
)
});
}
criterion_group! {
name = op_ser_benches;
config = Criterion::default();
targets = bench_pure_reads, bench_rw_pareto, bench_pure_write
}
criterion_main!(op_ser_benches);
| rust | Apache-2.0 | 690d85eb4790caed0bb2c11faf2b2e3e526bbf09 | 2026-01-04T20:21:42.422655Z | false |
vertexclique/lever | https://github.com/vertexclique/lever/blob/690d85eb4790caed0bb2c11faf2b2e3e526bbf09/benches/cuckoo_benches/src/main.rs | benches/cuckoo_benches/src/main.rs | use bustle::*;
use std::collections::HashMap;
use std::sync::RwLock;
use lever::prelude::*;
use std::hash::Hash;
// RwLock Table
#[derive(Clone)]
struct RwLockTable<K>(std::sync::Arc<RwLock<HashMap<K, u64>>>);
impl<K> Collection for RwLockTable<K>
where
K: Send + Sync + From<u64> + Copy + 'static + std::hash::Hash + Eq + std::fmt::Debug,
{
type Handle = Self;
fn with_capacity(capacity: usize) -> Self {
Self(std::sync::Arc::new(RwLock::new(HashMap::with_capacity(
capacity,
))))
}
fn pin(&self) -> Self::Handle {
self.clone()
}
}
impl<K> CollectionHandle for RwLockTable<K>
where
K: Send + Sync + From<u64> + Copy + 'static + std::hash::Hash + Eq + std::fmt::Debug,
{
type Key = K;
fn get(&mut self, key: &Self::Key) -> bool {
self.0.read().unwrap().get(key).is_some()
}
fn insert(&mut self, key: &Self::Key) -> bool {
self.0.write().unwrap().insert(*key, 1).is_none()
}
fn remove(&mut self, key: &Self::Key) -> bool {
self.0.write().unwrap().remove(key).is_some()
}
fn update(&mut self, key: &Self::Key) -> bool {
use std::collections::hash_map::Entry;
let mut map = self.0.write().unwrap();
if let Entry::Occupied(mut e) = map.entry(*key) {
e.insert(1);
true
} else {
false
}
}
}
// LOTable
#[derive(Clone)]
struct LOBenchTable<K>(std::sync::Arc<LOTable<K, u64>>)
where K: 'static + Send + Sync + Clone + Hash + Eq + Ord;
impl<K> Collection for LOBenchTable<K>
where
K: Send + Sync + From<u64> + Copy + 'static + std::hash::Hash + Eq + std::fmt::Debug + Ord,
{
type Handle = Self;
fn with_capacity(capacity: usize) -> Self {
Self(std::sync::Arc::new(LOTable::with_capacity(capacity)))
}
fn pin(&self) -> Self::Handle {
self.clone()
}
}
impl<K> CollectionHandle for LOBenchTable<K>
where
K: Send + Sync + From<u64> + Copy + 'static + std::hash::Hash + Eq + std::fmt::Debug + Ord,
{
type Key = K;
fn get(&mut self, key: &Self::Key) -> bool {
self.0.get(key).is_some()
}
fn insert(&mut self, key: &Self::Key) -> bool {
self.0.insert(*key, 1).map(|x| x.is_none()).unwrap()
}
fn remove(&mut self, key: &Self::Key) -> bool {
self.0.remove(key).map(|x| x.is_some()).unwrap()
}
fn update(&mut self, key: &Self::Key) -> bool {
if let Some(_x) = self.0.get(key) {
let _ = self.0.insert(*key, 1);
true
} else {
false
}
}
}
#[derive(Clone)]
struct HOPBenchTable<K>(std::sync::Arc<HOPTable<K, u64>>)
where K: 'static + Send + Sync + Clone + Hash + Eq + Ord + std::fmt::Debug;
impl<K> Collection for HOPBenchTable<K>
where
K: Send + Sync + From<u64> + Copy + 'static + std::hash::Hash + Eq + std::fmt::Debug + Ord,
{
type Handle = Self;
fn with_capacity(capacity: usize) -> Self {
Self(std::sync::Arc::new(HOPTable::with_capacity(capacity)))
}
fn pin(&self) -> Self::Handle {
self.clone()
}
}
impl<K> CollectionHandle for HOPBenchTable<K>
where
K: Send + Sync + From<u64> + Copy + 'static + std::hash::Hash + Eq + std::fmt::Debug + Ord,
{
type Key = K;
fn get(&mut self, key: &Self::Key) -> bool {
self.0.get(key).is_some()
}
fn insert(&mut self, key: &Self::Key) -> bool {
self.0.insert(*key, 1).map(|x| x.is_some()).unwrap()
}
fn remove(&mut self, key: &Self::Key) -> bool {
self.0.remove(key).map(|x| x.is_some()).unwrap()
}
fn update(&mut self, key: &Self::Key) -> bool {
if let Some(_x) = self.0.get(key) {
let _ = self.0.insert(*key, 1);
true
} else {
false
}
}
}
fn main() {
tracing_subscriber::fmt::init();
// let num_threads = num_cpus::get();
let num_threads = 8;
println!("=========== RwLock =============");
// Workload::new(10, Mix::read_heavy()).run::<RwLockTable<u64>>();
for n in 1..=num_threads {
Workload::new(n, Mix::read_heavy()).run::<RwLockTable<u64>>();
}
println!("=========== LOTable =============");
// for n in 1..=num_threads {
// Workload::new(n, Mix::read_heavy()).run::<LOBenchTable<u64>>();
// }
println!("=========== HOPTable =============");
// Workload::new(8, Mix::read_heavy()).run::<HOPBenchTable<u64>>();
for n in 1..=num_threads {
Workload::new(n, Mix::read_heavy()).run::<HOPBenchTable<u64>>();
}
}
| rust | Apache-2.0 | 690d85eb4790caed0bb2c11faf2b2e3e526bbf09 | 2026-01-04T20:21:42.422655Z | false |
vertexclique/lever | https://github.com/vertexclique/lever/blob/690d85eb4790caed0bb2c11faf2b2e3e526bbf09/examples/arc_rwlock.rs | examples/arc_rwlock.rs | use std::collections::HashMap;
use std::sync::{Arc, RwLock};
fn main() {
let lotable: Arc<RwLock<HashMap<String, u64>>> = Arc::new(RwLock::new(HashMap::default()));
// RW from 1_000 threads concurrently.
let thread_count = 8;
let mut threads = vec![];
for thread_no in 0..thread_count {
let lotable = lotable.clone();
let t = std::thread::Builder::new()
.name(format!("t_{}", thread_no))
.spawn(move || {
let key = format!("{}", thread_no);
let mut loguard = lotable.write().unwrap();
loguard.insert(key.clone(), thread_no);
drop(loguard);
let loguard = lotable.read().unwrap();
let _ = loguard.get(&key).unwrap();
})
.unwrap();
threads.push(t);
}
for t in threads.into_iter() {
t.join().unwrap();
}
}
| rust | Apache-2.0 | 690d85eb4790caed0bb2c11faf2b2e3e526bbf09 | 2026-01-04T20:21:42.422655Z | false |
vertexclique/lever | https://github.com/vertexclique/lever/blob/690d85eb4790caed0bb2c11faf2b2e3e526bbf09/examples/basic_txn.rs | examples/basic_txn.rs | use lever::txn::prelude::*;
fn main() {
let manager = lever::lever().manager();
let txn = manager.txn_build(
// Select concurrency scheme
TransactionConcurrency::Optimistic,
// Select isolation scheme
TransactionIsolation::RepeatableRead,
// Give timeout for transaction conflict resolution in milliseconds
100_usize,
// Work element size inside the given transaction
1_usize,
// Name of the transaction
"basic_txn".into(),
);
let mut customers = TVar::new(123_456);
println!("I have {} customers right now.", customers.get_data());
txn.begin(|t| {
let mut churned = t.read(&customers);
churned += 1;
t.write(&mut customers, churned);
});
println!(
"I have {} customers right now. I gained 1.",
customers.get_data()
);
// You don't necessarily need to use convenience methods.
txn.begin(|t| {
let mut churned = *customers;
churned -= 123_000;
t.write(&mut customers, churned);
});
println!(
"I have {} customers right now. I think I lost a lot.",
customers.get_data()
);
}
| rust | Apache-2.0 | 690d85eb4790caed0bb2c11faf2b2e3e526bbf09 | 2026-01-04T20:21:42.422655Z | false |
vertexclique/lever | https://github.com/vertexclique/lever/blob/690d85eb4790caed0bb2c11faf2b2e3e526bbf09/examples/lotable.rs | examples/lotable.rs | use lever::prelude::*;
use std::sync::Arc;
fn main() {
let lotable: Arc<LOTable<String, u64>> = Arc::new(LOTable::new());
// RW from 1_000 threads concurrently.
let thread_count = 8;
let mut threads = vec![];
for thread_no in 0..thread_count {
let lotable = lotable.clone();
let t = std::thread::Builder::new()
.name(format!("t_{}", thread_no))
.spawn(move || {
let key = format!("{}", thread_no);
lotable.insert(key.clone(), thread_no);
let _ = lotable.get(&key).unwrap();
})
.unwrap();
threads.push(t);
}
for t in threads.into_iter() {
t.join().unwrap();
}
}
| rust | Apache-2.0 | 690d85eb4790caed0bb2c11faf2b2e3e526bbf09 | 2026-01-04T20:21:42.422655Z | false |
soybeanjs/soybean-admin-rust | https://github.com/soybeanjs/soybean-admin-rust/blob/a560191ee087ba509e2060f17937b9f2c8f9be33/xdb/src/ip_value.rs | xdb/src/ip_value.rs | use std::{error::Error, net::Ipv4Addr, str::FromStr};
pub trait ToUIntIP {
fn to_u32_ip(&self) -> Result<u32, Box<dyn Error>>;
}
impl ToUIntIP for u32 {
#[inline(always)]
fn to_u32_ip(&self) -> Result<u32, Box<dyn Error>> {
Ok(*self)
}
}
impl ToUIntIP for &str {
#[inline(always)]
fn to_u32_ip(&self) -> Result<u32, Box<dyn Error>> {
if let Ok(num) = self.parse::<u32>() {
return Ok(num);
}
Ok(u32::from(Ipv4Addr::from_str(self)?))
}
}
impl ToUIntIP for Ipv4Addr {
#[inline(always)]
fn to_u32_ip(&self) -> Result<u32, Box<dyn Error>> {
Ok(u32::from(*self))
}
}
#[cfg(test)]
mod test_ip {
use super::*;
#[test]
fn test_ip_str_2_u32() {
let ip_str = "1.1.1.1";
let result = ip_str.to_u32_ip().unwrap();
assert_eq!(result, 1 << 24 | 1 << 16 | 1 << 8 | 1);
}
#[test]
fn test_ip_u32_str() {
let ip = "12";
let result = ip.to_u32_ip().unwrap();
assert_eq!(result, 12);
}
#[test]
fn test_ip_u32() {
let ip: u32 = 33;
let result = ip.to_u32_ip().unwrap();
assert_eq!(result, 33);
}
#[test]
fn test_ip_addr() {
let ip = Ipv4Addr::from_str("0.0.3.12").unwrap();
let result = ip.to_u32_ip().unwrap();
assert_eq!(result, 3 << 8 | 12)
}
}
| rust | Apache-2.0 | a560191ee087ba509e2060f17937b9f2c8f9be33 | 2026-01-04T20:21:43.261270Z | false |
soybeanjs/soybean-admin-rust | https://github.com/soybeanjs/soybean-admin-rust/blob/a560191ee087ba509e2060f17937b9f2c8f9be33/xdb/src/searcher.rs | xdb/src/searcher.rs | use std::{error::Error, fmt::Display, fs::File, io::Read, path::Path};
use once_cell::sync::OnceCell;
use crate::ToUIntIP;
const HEADER_INFO_LENGTH: usize = 256;
const VECTOR_INDEX_COLS: usize = 256;
const VECTOR_INDEX_SIZE: usize = 8;
const SEGMENT_INDEX_SIZE: usize = 14;
const VECTOR_INDEX_LENGTH: usize = 512 * 1024;
const XDB_FILEPATH_ENV: &str = "XDB_FILEPATH";
// 只保留一个缓存，用于存储完整数据
static CACHE: OnceCell<Vec<u8>> = OnceCell::new();
// 添加专门的向量缓存
static VECTOR_CACHE: OnceCell<&'static [u8]> = OnceCell::new();
fn default_detect_xdb_file() -> Result<String, Box<dyn Error>> {
let prefix = "../".to_owned();
for recurse in 1..4 {
let filepath = prefix.repeat(recurse) + "server/resources/ip2region.xdb";
if Path::new(&filepath).exists() {
return Ok(filepath);
}
}
Err("default filepath not find the xdb file".into())
}
#[inline(always)]
pub fn get_block_by_size(bytes: &[u8], offset: usize, length: usize) -> usize {
unsafe {
let ptr = bytes.as_ptr().add(offset);
match length {
4 => {
let mut buf = [0u8; 4];
std::ptr::copy_nonoverlapping(ptr, buf.as_mut_ptr(), 4);
u32::from_ne_bytes(buf) as usize
},
2 => {
let mut buf = [0u8; 2];
std::ptr::copy_nonoverlapping(ptr, buf.as_mut_ptr(), 2);
u16::from_ne_bytes(buf) as usize
},
_ => {
let mut result = 0usize;
std::ptr::copy_nonoverlapping(ptr, &mut result as *mut usize as *mut u8, length);
result
},
}
}
}
#[inline(always)]
pub fn search_by_ip<T>(ip: T) -> Result<String, Box<dyn Error>>
where
T: ToUIntIP + Display,
{
let ip = ip.to_u32_ip()?;
unsafe {
let vector_cache = get_vector_index_cache();
let offset = VECTOR_INDEX_SIZE
* ((((ip >> 24) & 0xFF) as usize) * VECTOR_INDEX_COLS + ((ip >> 16) & 0xFF) as usize);
// 使用 get_block_by_size 来安全地读取数据
let start_ptr = get_block_by_size(vector_cache, offset, 4);
let end_ptr = get_block_by_size(vector_cache, offset + 4, 4);
let full_cache = get_full_cache();
let cache_ptr = full_cache.as_ptr().add(start_ptr);
let mut left = 0;
let mut right = (end_ptr - start_ptr) / SEGMENT_INDEX_SIZE;
while left < right {
let mid = (left + right) >> 1;
let segment_offset = mid * SEGMENT_INDEX_SIZE;
let _segment_ptr = cache_ptr.add(segment_offset);
// 使用 get_block_by_size 读取所有数据
let start_ip = get_block_by_size(full_cache, start_ptr + segment_offset, 4) as u32;
if ip < start_ip {
right = mid;
continue;
}
let end_ip = get_block_by_size(full_cache, start_ptr + segment_offset + 4, 4) as u32;
if ip > end_ip {
left = mid + 1;
continue;
}
let data_len = get_block_by_size(full_cache, start_ptr + segment_offset + 8, 2);
let data_offset = get_block_by_size(full_cache, start_ptr + segment_offset + 10, 4);
let data = std::slice::from_raw_parts(full_cache.as_ptr().add(data_offset), data_len);
return Ok(String::from_utf8_unchecked(data.to_vec()));
}
Err("not matched".into())
}
}
// 优化向量索引缓存访问
#[inline(always)]
pub fn get_vector_index_cache() -> &'static [u8] {
// 使用静态缓存，只计算一次
VECTOR_CACHE.get_or_init(|| unsafe {
let full_cache = get_full_cache();
let ptr = full_cache.as_ptr().add(HEADER_INFO_LENGTH);
std::slice::from_raw_parts(ptr, VECTOR_INDEX_LENGTH)
})
}
#[inline(always)]
pub fn get_full_cache() -> &'static Vec<u8> {
CACHE.get_or_init(|| {
let xdb_filepath =
std::env::var(XDB_FILEPATH_ENV).unwrap_or_else(|_| default_detect_xdb_file().unwrap());
let size = std::fs::metadata(&xdb_filepath)
.map(|m| m.len() as usize)
.unwrap_or(1024 * 1024);
let mut buffer = Vec::with_capacity(size);
File::open(&xdb_filepath)
.expect("file open error")
.read_to_end(&mut buffer)
.expect("load file error");
buffer
})
}
pub fn searcher_init(xdb_filepath: Option<String>) {
let xdb_filepath = xdb_filepath.unwrap_or_else(|| default_detect_xdb_file().unwrap());
std::env::set_var(XDB_FILEPATH_ENV, xdb_filepath);
// 初始化并预热两个缓存
let _ = get_full_cache();
let _ = get_vector_index_cache();
}
#[cfg(test)]
mod tests {
use std::{fs::File, io::Read, net::Ipv4Addr, str::FromStr, thread};
use super::*;
/// test all types find correct
#[test]
fn test_multi_type_ip() {
searcher_init(None);
search_by_ip("2.0.0.0").unwrap();
search_by_ip("32").unwrap();
search_by_ip(4294408949).unwrap();
search_by_ip(Ipv4Addr::from_str("1.1.1.1").unwrap()).unwrap();
}
#[test]
fn test_match_all_ip_correct() {
searcher_init(None);
let mut file = File::open("../server/resources/ip.test.txt").unwrap();
let mut contents = String::new();
file.read_to_string(&mut contents).unwrap();
for line in contents.split("\n") {
if !line.contains("|") {
continue;
}
let ip_test_line = line.splitn(3, "|").collect::<Vec<&str>>();
let start_ip = Ipv4Addr::from_str(ip_test_line[0]).unwrap();
let end_ip = Ipv4Addr::from_str(ip_test_line[1]).unwrap();
for value in u32::from(start_ip)..u32::from(end_ip) + 1 {
let result = search_by_ip(value).unwrap();
assert_eq!(result.as_str(), ip_test_line[2])
}
}
}
#[test]
fn test_multi_thread_only_load_xdb_once() {
searcher_init(None);
let handle = thread::spawn(|| {
let result = search_by_ip("2.2.2.2").unwrap();
println!("ip search in spawn: {result}");
});
let r = search_by_ip("1.1.1.1").unwrap();
println!("ip search in main thread: {r}");
handle.join().unwrap();
}
#[test]
fn test_multi_searcher_init() {
for _ in 0..5 {
thread::spawn(|| {
searcher_init(None);
});
}
searcher_init(None);
searcher_init(Some(String::from("test")));
search_by_ip(123).unwrap();
}
}
| rust | Apache-2.0 | a560191ee087ba509e2060f17937b9f2c8f9be33 | 2026-01-04T20:21:43.261270Z | false |
soybeanjs/soybean-admin-rust | https://github.com/soybeanjs/soybean-admin-rust/blob/a560191ee087ba509e2060f17937b9f2c8f9be33/xdb/src/lib.rs | xdb/src/lib.rs | mod ip_value;
pub use self::ip_value::ToUIntIP;
pub mod searcher;
pub use searcher::{search_by_ip, searcher_init};
| rust | Apache-2.0 | a560191ee087ba509e2060f17937b9f2c8f9be33 | 2026-01-04T20:21:43.261270Z | false |
soybeanjs/soybean-admin-rust | https://github.com/soybeanjs/soybean-admin-rust/blob/a560191ee087ba509e2060f17937b9f2c8f9be33/xdb/benches/search.rs | xdb/benches/search.rs | use criterion::{black_box, criterion_group, criterion_main, Criterion};
use rand;
use xdb::searcher::{
get_block_by_size, get_full_cache, get_vector_index_cache, search_by_ip, searcher_init,
};
fn search_by_ip_bench(c: &mut Criterion) {
c.bench_function("search_by_ip_bench", |b| {
searcher_init(None);
b.iter(|| {
search_by_ip(rand::random::<u32>()).unwrap();
})
});
}
fn get_block_by_size_bench(c: &mut Criterion) {
c.bench_function("get_block_by_size_bench", |b| {
b.iter(|| {
black_box(get_block_by_size(
get_full_cache(),
rand::random::<u16>() as usize,
4,
));
})
});
}
fn get_full_cache_bench(c: &mut Criterion) {
c.bench_function("get_full_cache_bench", |b| {
b.iter(|| {
black_box(get_full_cache());
})
});
}
fn get_vec_index_cache_bench(c: &mut Criterion) {
c.bench_function("get_vec_index_cache_bench", |b| {
b.iter(|| {
black_box(get_vector_index_cache());
})
});
}
criterion_group!(
benches,
search_by_ip_bench,
get_block_by_size_bench,
get_full_cache_bench,
get_vec_index_cache_bench,
);
criterion_main!(benches);
| rust | Apache-2.0 | a560191ee087ba509e2060f17937b9f2c8f9be33 | 2026-01-04T20:21:43.261270Z | false |
soybeanjs/soybean-admin-rust | https://github.com/soybeanjs/soybean-admin-rust/blob/a560191ee087ba509e2060f17937b9f2c8f9be33/sea-orm-adapter/src/lib.rs | sea-orm-adapter/src/lib.rs | pub use adapter::SeaOrmAdapter;
pub use migration::{down, up};
mod action;
mod adapter;
pub mod entity;
mod migration;
| rust | Apache-2.0 | a560191ee087ba509e2060f17937b9f2c8f9be33 | 2026-01-04T20:21:43.261270Z | false |
soybeanjs/soybean-admin-rust | https://github.com/soybeanjs/soybean-admin-rust/blob/a560191ee087ba509e2060f17937b9f2c8f9be33/sea-orm-adapter/src/entity.rs | sea-orm-adapter/src/entity.rs | //! `SeaORM` Entity. Generated by sea-orm-codegen 0.12.15
use sea_orm::entity::prelude::*;
#[derive(Clone, Debug, PartialEq, DeriveEntityModel, Eq)]
#[sea_orm(table_name = "casbin_rule")]
pub struct Model {
#[sea_orm(primary_key)]
pub id: i64,
pub ptype: String,
pub v0: String,
pub v1: String,
pub v2: String,
pub v3: String,
pub v4: String,
pub v5: String,
}
#[derive(Copy, Clone, Debug, EnumIter, DeriveRelation)]
pub enum Relation {}
impl ActiveModelBehavior for ActiveModel {}
| rust | Apache-2.0 | a560191ee087ba509e2060f17937b9f2c8f9be33 | 2026-01-04T20:21:43.261270Z | false |
soybeanjs/soybean-admin-rust | https://github.com/soybeanjs/soybean-admin-rust/blob/a560191ee087ba509e2060f17937b9f2c8f9be33/sea-orm-adapter/src/adapter.rs | sea-orm-adapter/src/adapter.rs | use async_trait::async_trait;
use casbin::{error::AdapterError, Adapter, Error as CasbinError, Filter, Model, Result};
use sea_orm::ConnectionTrait;
use crate::{
action::{self, Rule, RuleWithType},
entity, migration,
};
pub struct SeaOrmAdapter<C> {
conn: C,
is_filtered: bool,
}
impl<C: ConnectionTrait> SeaOrmAdapter<C> {
pub async fn new(conn: C) -> Result<Self> {
migration::up(&conn)
.await
.map(|_| Self {
conn,
is_filtered: false,
})
.map_err(|err| CasbinError::from(AdapterError(Box::new(err))))
}
}
impl<C> SeaOrmAdapter<C> {
fn transform_policy_line<'a>(ptype: &'a str, rule: &'a [String]) -> Option<RuleWithType<'a>> {
if ptype.trim().is_empty() || rule.is_empty() {
return None;
}
Some(RuleWithType::from_rule(ptype, Rule::from_slice(rule)))
}
fn normalize_policy(model: &entity::Model) -> Option<Vec<String>> {
let policy: Vec<_> = [
&model.v0, &model.v1, &model.v2, &model.v3, &model.v4, &model.v5,
]
.iter()
.take_while(|&&v| !v.is_empty())
.map(|&s| s.to_owned())
.collect();
if policy.is_empty() {
None
} else {
Some(policy)
}
}
}
#[async_trait]
impl<C: ConnectionTrait + Send + Sync> Adapter for SeaOrmAdapter<C> {
async fn load_policy(&mut self, m: &mut dyn Model) -> Result<()> {
let rules = action::load_policy(&self.conn).await?;
for rule in &rules {
if let Some(sec) = rule.ptype.chars().next().map(|x| x.to_string()) {
if let Some(t1) = m.get_mut_model().get_mut(&sec) {
if let Some(t2) = t1.get_mut(&rule.ptype) {
if let Some(policy) = Self::normalize_policy(rule) {
t2.get_mut_policy().insert(policy);
}
}
}
}
}
Ok(())
}
async fn load_filtered_policy<'a>(&mut self, m: &mut dyn Model, f: Filter<'a>) -> Result<()> {
let rules = action::load_filtered_policy(&self.conn, f).await?;
self.is_filtered = true;
for rule in &rules {
if let Some(sec) = rule.ptype.chars().next().map(|x| x.to_string()) {
if let Some(t1) = m.get_mut_model().get_mut(&sec) {
if let Some(t2) = t1.get_mut(&rule.ptype) {
if let Some(policy) = Self::normalize_policy(rule) {
t2.get_mut_policy().insert(policy);
}
}
}
}
}
Ok(())
}
async fn save_policy(&mut self, m: &mut dyn Model) -> Result<()> {
let mut rules = Vec::new();
let mut process_policy_type = |ptype: &str| {
if let Some(ast_map) = m.get_model().get(ptype) {
for (ptype, ast) in ast_map {
let new_rules = ast
.get_policy()
.iter()
.filter_map(|x| Self::transform_policy_line(ptype, x));
rules.extend(new_rules);
}
}
};
process_policy_type("p");
process_policy_type("g");
action::save_policies(&self.conn, rules).await
}
async fn clear_policy(&mut self) -> Result<()> {
action::clear_policy(&self.conn).await
}
fn is_filtered(&self) -> bool {
self.is_filtered
}
async fn add_policy(&mut self, _sec: &str, ptype: &str, rule: Vec<String>) -> Result<bool> {
if let Some(rule_with_type) = Self::transform_policy_line(ptype, &rule) {
action::add_policy(&self.conn, rule_with_type).await
} else {
Ok(false)
}
}
async fn add_policies(
&mut self,
_sec: &str,
ptype: &str,
rules: Vec<Vec<String>>,
) -> Result<bool> {
let rules: Vec<_> = rules
.iter()
.filter_map(|x| Self::transform_policy_line(ptype, x))
.collect();
if rules.is_empty() {
return Ok(false);
}
action::add_policies(&self.conn, rules).await
}
async fn remove_policy(&mut self, _sec: &str, ptype: &str, rule: Vec<String>) -> Result<bool> {
if let Some(rule_with_type) = Self::transform_policy_line(ptype, &rule) {
action::remove_policy(&self.conn, rule_with_type).await
} else {
Ok(false)
}
}
async fn remove_policies(
&mut self,
_sec: &str,
ptype: &str,
rules: Vec<Vec<String>>,
) -> Result<bool> {
let rules: Vec<_> = rules
.iter()
.filter_map(|x| Self::transform_policy_line(ptype, x))
.collect();
if rules.is_empty() {
return Ok(false);
}
action::remove_policies(&self.conn, rules).await
}
async fn remove_filtered_policy(
&mut self,
_sec: &str,
ptype: &str,
field_index: usize,
field_values: Vec<String>,
) -> Result<bool> {
if field_index <= 5 && !field_values.is_empty() && field_values.len() + field_index <= 6 {
let rule = Rule::from_slice(&field_values);
action::remove_filtered_policy(&self.conn, ptype, field_index, rule).await
} else {
Ok(false)
}
}
}
// Copy from https://github.com/casbin-rs/sqlx-adapter/blob/master/src/adapter.rs
#[cfg(test)]
mod tests {
use std::time::Duration;
use casbin::Adapter;
use sea_orm::{ConnectOptions, Database};
use crate::adapter::SeaOrmAdapter;
fn to_owned(v: Vec<&str>) -> Vec<String> {
v.into_iter().map(|x| x.to_owned()).collect()
}
#[cfg_attr(
any(feature = "runtime-tokio-native-tls", feature = "runtime-tokio-rustls"),
tokio::test(flavor = "multi_thread")
)]
#[cfg_attr(
any(feature = "runtime-actix-native-tls", feature = "runtime-actix-rustls"),
actix_rt::test
)]
async fn test_adapter() {
use casbin::prelude::*;
let file_adapter = FileAdapter::new("examples/rbac_policy.csv");
let m = DefaultModel::from_file("examples/rbac_model.conf")
.await
.unwrap();
let mut e = Enforcer::new(m, file_adapter).await.unwrap();
let db_url = {
#[cfg(feature = "postgres")]
{
"postgresql://soybean:soybean@123.@localhost:35432/soybean-admin-rust-backend"
}
#[cfg(feature = "mysql")]
{
"mysql://root:123456@localhost:3306/casbin"
}
#[cfg(feature = "sqlite")]
{
"sqlite:casbin.db"
}
};
let mut opt = ConnectOptions::new(db_url.to_owned());
opt.max_connections(100)
.min_connections(5)
.connect_timeout(Duration::from_secs(8))
.acquire_timeout(Duration::from_secs(8))
.idle_timeout(Duration::from_secs(8))
.max_lifetime(Duration::from_secs(8));
let db = Database::connect(opt).await.unwrap();
let mut adapter = SeaOrmAdapter::new(db).await.unwrap();
assert!(adapter.save_policy(e.get_mut_model()).await.is_ok());
assert!(adapter
.remove_policy("", "p", to_owned(vec!["alice", "data1", "read"]))
.await
.unwrap());
assert!(adapter
.remove_policy("", "p", to_owned(vec!["bob", "data2", "write"]))
.await
.is_ok());
assert!(adapter
.remove_policy("", "p", to_owned(vec!["data2_admin", "data2", "read"]))
.await
.is_ok());
assert!(adapter
.remove_policy("", "p", to_owned(vec!["data2_admin", "data2", "write"]))
.await
.is_ok());
assert!(adapter
.remove_policy("", "g", to_owned(vec!["alice", "data2_admin"]))
.await
.is_ok());
assert!(adapter
.add_policy("", "p", to_owned(vec!["alice", "data1", "read"]))
.await
.is_ok());
assert!(adapter
.add_policy("", "p", to_owned(vec!["bob", "data2", "write"]))
.await
.is_ok());
assert!(adapter
.add_policy("", "p", to_owned(vec!["data2_admin", "data2", "read"]))
.await
.is_ok());
assert!(adapter
.add_policy("", "p", to_owned(vec!["data2_admin", "data2", "write"]))
.await
.is_ok());
assert!(adapter
.remove_policies(
"",
"p",
vec![
to_owned(vec!["alice", "data1", "read"]),
to_owned(vec!["bob", "data2", "write"]),
to_owned(vec!["data2_admin", "data2", "read"]),
to_owned(vec!["data2_admin", "data2", "write"]),
]
)
.await
.is_ok());
assert!(adapter
.add_policies(
"",
"p",
vec![
to_owned(vec!["alice", "data1", "read"]),
to_owned(vec!["bob", "data2", "write"]),
to_owned(vec!["data2_admin", "data2", "read"]),
to_owned(vec!["data2_admin", "data2", "write"]),
]
)
.await
.is_ok());
assert!(adapter
.add_policy("", "g", to_owned(vec!["alice", "data2_admin"]))
.await
.is_ok());
assert!(adapter
.remove_policy("", "p", to_owned(vec!["alice", "data1", "read"]))
.await
.is_ok());
assert!(adapter
.remove_policy("", "p", to_owned(vec!["bob", "data2", "write"]))
.await
.is_ok());
assert!(adapter
.remove_policy("", "p", to_owned(vec!["data2_admin", "data2", "read"]))
.await
.is_ok());
assert!(adapter
.remove_policy("", "p", to_owned(vec!["data2_admin", "data2", "write"]))
.await
.is_ok());
assert!(adapter
.remove_policy("", "g", to_owned(vec!["alice", "data2_admin"]))
.await
.is_ok());
assert!(!adapter
.remove_policy(
"",
"g",
to_owned(vec!["alice", "data2_admin", "not_exists"])
)
.await
.unwrap());
assert!(adapter
.add_policy("", "g", to_owned(vec!["alice", "data2_admin"]))
.await
.is_ok());
assert!(adapter
.add_policy("", "g", to_owned(vec!["alice", "data2_admin"]))
.await
.is_err());
assert!(!adapter
.remove_filtered_policy(
"",
"g",
0,
to_owned(vec!["alice", "data2_admin", "not_exists"]),
)
.await
.unwrap());
assert!(adapter
.remove_filtered_policy("", "g", 0, to_owned(vec!["alice", "data2_admin"]))
.await
.unwrap());
assert!(adapter
.add_policy(
"",
"g",
to_owned(vec!["alice", "data2_admin", "domain1", "domain2"]),
)
.await
.is_ok());
assert!(adapter
.remove_filtered_policy(
"",
"g",
1,
to_owned(vec!["data2_admin", "domain1", "domain2"]),
)
.await
.unwrap());
// GitHub issue: https://github.com/casbin-rs/sqlx-adapter/issues/64
assert!(adapter
.add_policy("", "g", to_owned(vec!["carol", "data1_admin"]),)
.await
.is_ok());
assert!(adapter
.remove_filtered_policy("", "g", 0, to_owned(vec!["carol"]),)
.await
.unwrap());
assert_eq!(vec![String::new(); 0], e.get_roles_for_user("carol", None));
// GitHub issue: https://github.com/casbin-rs/sqlx-adapter/pull/90
// add policies:
// p, alice_rfp, book_rfp, read_rfp
// p, bob_rfp, book_rfp, read_rfp
// p, bob_rfp, book_rfp, write_rfp
// p, alice_rfp, pen_rfp, get_rfp
// p, bob_rfp, pen_rfp, get_rfp
// p, alice_rfp, pencil_rfp, get_rfp
assert!(adapter
.add_policy("", "p", to_owned(vec!["alice_rfp", "book_rfp", "read_rfp"]),)
.await
.is_ok());
assert!(adapter
.add_policy("", "p", to_owned(vec!["bob_rfp", "book_rfp", "read_rfp"]),)
.await
.is_ok());
assert!(adapter
.add_policy("", "p", to_owned(vec!["bob_rfp", "book_rfp", "write_rfp"]),)
.await
.is_ok());
assert!(adapter
.add_policy("", "p", to_owned(vec!["alice_rfp", "pen_rfp", "get_rfp"]),)
.await
.is_ok());
assert!(adapter
.add_policy("", "p", to_owned(vec!["bob_rfp", "pen_rfp", "get_rfp"]),)
.await
.is_ok());
assert!(adapter
.add_policy(
"",
"p",
to_owned(vec!["alice_rfp", "pencil_rfp", "get_rfp"]),
)
.await
.is_ok());
// should remove (return true) all policies where "book_rfp" is in the second
// position
assert!(adapter
.remove_filtered_policy("", "p", 1, to_owned(vec!["book_rfp"]),)
.await
.unwrap());
// should remove (return true) all policies which match "alice_rfp" on first
// position and "get_rfp" on third position
assert!(adapter
.remove_filtered_policy("", "p", 0, to_owned(vec!["alice_rfp", "", "get_rfp"]),)
.await
.unwrap());
// shadow the previous enforcer
let mut e = Enforcer::new(
"examples/rbac_with_domains_model.conf",
"examples/rbac_with_domains_policy.csv",
)
.await
.unwrap();
assert!(adapter.save_policy(e.get_mut_model()).await.is_ok());
e.set_adapter(adapter).await.unwrap();
let filter = Filter {
p: vec!["", "domain1"],
g: vec!["", "", "domain1"],
};
e.load_filtered_policy(filter).await.unwrap();
assert!(e.enforce(("alice", "domain1", "data1", "read")).unwrap());
assert!(e.enforce(("alice", "domain1", "data1", "write")).unwrap());
assert!(!e.enforce(("alice", "domain1", "data2", "read")).unwrap());
assert!(!e.enforce(("alice", "domain1", "data2", "write")).unwrap());
assert!(!e.enforce(("bob", "domain2", "data2", "read")).unwrap());
assert!(!e.enforce(("bob", "domain2", "data2", "write")).unwrap());
}
}
| rust | Apache-2.0 | a560191ee087ba509e2060f17937b9f2c8f9be33 | 2026-01-04T20:21:43.261270Z | false |
soybeanjs/soybean-admin-rust | https://github.com/soybeanjs/soybean-admin-rust/blob/a560191ee087ba509e2060f17937b9f2c8f9be33/sea-orm-adapter/src/action.rs | sea-orm-adapter/src/action.rs | use casbin::{error::AdapterError, Error as CasbinError, Filter, Result};
use sea_orm::{
ActiveModelTrait,
ActiveValue::{NotSet, Set},
ColumnTrait, Condition, ConnectionTrait, EntityTrait, QueryFilter,
};
use crate::entity::{self, Column, Entity};
const COLUMNS: [Column; 6] = [
Column::V0,
Column::V1,
Column::V2,
Column::V3,
Column::V4,
Column::V5,
];
#[derive(Debug, Default)]
pub(crate) struct Rule<'a> {
pub(crate) values: [&'a str; 6],
}
impl<'a> Rule<'a> {
pub(crate) fn from_slice<T: AsRef<str>>(value: &'a [T]) -> Self {
let mut values = [""; 6];
for (i, v) in value.iter().enumerate().take(6) {
values[i] = v.as_ref();
}
Rule { values }
}
}
#[derive(Debug, Default)]
pub(crate) struct RuleWithType<'a> {
pub(crate) ptype: &'a str,
pub(crate) rule: Rule<'a>,
}
impl<'a> RuleWithType<'a> {
pub(crate) fn from_rule(ptype: &'a str, rule: Rule<'a>) -> Self {
RuleWithType { ptype, rule }
}
}
pub(crate) async fn remove_policy<'conn, 'rule, C: ConnectionTrait>(
conn: &'conn C,
rule: RuleWithType<'rule>,
) -> Result<bool> {
let mut delete = Entity::delete_many().filter(Column::Ptype.eq(rule.ptype));
for (column, value) in COLUMNS.iter().zip(rule.rule.values.iter()) {
delete = delete.filter(column.eq(*value));
}
delete
.exec(conn)
.await
.map(|count| count.rows_affected == 1)
.map_err(|err| CasbinError::from(AdapterError(Box::new(err))))
}
pub(crate) async fn remove_policies<'conn, 'rule, C: ConnectionTrait>(
conn: &'conn C,
rules: Vec<RuleWithType<'rule>>,
) -> Result<bool> {
for rule in rules {
remove_policy(conn, rule).await?;
}
Ok(true)
}
pub(crate) async fn remove_filtered_policy<'conn, 'rule, C: ConnectionTrait>(
conn: &'conn C,
ptype: &'rule str,
index_of_match_start: usize,
rule: Rule<'rule>,
) -> Result<bool> {
let base_condition = Condition::all().add(Column::Ptype.eq(ptype));
let conditions = rule.values[index_of_match_start..]
.iter()
.zip(&COLUMNS[index_of_match_start..])
.filter(|(value, _)| !value.is_empty())
.fold(base_condition, |acc, (value, column)| {
acc.add(column.eq(*value))
});
Entity::delete_many()
.filter(conditions)
.exec(conn)
.await
.map(|count| count.rows_affected >= 1)
.map_err(|err| CasbinError::from(AdapterError(Box::new(err))))
}
pub(crate) async fn load_policy<C: ConnectionTrait>(conn: &C) -> Result<Vec<entity::Model>> {
entity::Entity::find()
.all(conn)
.await
.map_err(|err| CasbinError::from(AdapterError(Box::new(err))))
}
pub(crate) async fn load_filtered_policy<'conn, 'filter, C: ConnectionTrait>(
conn: &'conn C,
filter: Filter<'filter>,
) -> Result<Vec<entity::Model>> {
let g_filter = Rule::from_slice(&filter.g);
let p_filter = Rule::from_slice(&filter.p);
let g_condition = create_condition_from_rule("g", &g_filter);
let p_condition = create_condition_from_rule("p", &p_filter);
Entity::find()
.filter(Condition::any().add(g_condition).add(p_condition))
.all(conn)
.await
.map_err(|err| CasbinError::from(AdapterError(Box::new(err))))
}
fn create_condition_from_rule(prefix: &str, rule: &Rule) -> Condition {
rule.values
.iter()
.zip(COLUMNS.iter())
.filter(|(value, _)| !value.is_empty())
.fold(
Condition::all().add(Column::Ptype.starts_with(prefix)),
|acc, (value, column)| acc.add(column.eq(*value)),
)
}
pub(crate) async fn save_policies<'conn, 'rule, C: ConnectionTrait>(
conn: &'conn C,
rules: Vec<RuleWithType<'rule>>,
) -> Result<()> {
clear_policy(conn).await?;
add_policies(conn, rules).await?;
Ok(())
}
pub(crate) async fn add_policy<'conn, 'rule, C: ConnectionTrait>(
conn: &'conn C,
rule: RuleWithType<'rule>,
) -> Result<bool> {
let model = create_active_model(&rule);
model
.insert(conn)
.await
.map(|_| true)
.map_err(|err| CasbinError::from(AdapterError(Box::new(err))))
}
pub(crate) async fn add_policies<'conn, 'rule, C: ConnectionTrait>(
conn: &'conn C,
rules: Vec<RuleWithType<'rule>>,
) -> Result<bool> {
let models: Vec<entity::ActiveModel> = rules.iter().map(create_active_model).collect();
Entity::insert_many(models)
.exec(conn)
.await
.map(|_| true)
.map_err(|err| CasbinError::from(AdapterError(Box::new(err))))
}
fn create_active_model(rule: &RuleWithType) -> entity::ActiveModel {
entity::ActiveModel {
id: NotSet,
ptype: Set(rule.ptype.to_string()),
v0: Set(rule.rule.values[0].to_string()),
v1: Set(rule.rule.values[1].to_string()),
v2: Set(rule.rule.values[2].to_string()),
v3: Set(rule.rule.values[3].to_string()),
v4: Set(rule.rule.values[4].to_string()),
v5: Set(rule.rule.values[5].to_string()),
}
}
pub(crate) async fn clear_policy<C: ConnectionTrait>(conn: &C) -> Result<()> {
Entity::delete_many()
.exec(conn)
.await
.map_err(|err| CasbinError::from(AdapterError(Box::new(err))))?;
Ok(())
}
| rust | Apache-2.0 | a560191ee087ba509e2060f17937b9f2c8f9be33 | 2026-01-04T20:21:43.261270Z | false |
soybeanjs/soybean-admin-rust | https://github.com/soybeanjs/soybean-admin-rust/blob/a560191ee087ba509e2060f17937b9f2c8f9be33/sea-orm-adapter/src/migration.rs | sea-orm-adapter/src/migration.rs | use sea_orm::{
sea_query::{ColumnDef, Index, Table},
ConnectionTrait, DbErr, DeriveIden, ExecResult,
};
#[derive(DeriveIden)]
enum CasbinRule {
Table,
Id,
Ptype,
V0,
V1,
V2,
V3,
V4,
V5,
}
pub async fn up<C: ConnectionTrait>(conn: &C) -> Result<ExecResult, DbErr> {
let create_table = Table::create()
.if_not_exists()
.table(CasbinRule::Table)
.col(
ColumnDef::new(CasbinRule::Id)
.big_integer()
.not_null()
.auto_increment()
.primary_key(),
)
// MySQL max key length is `3072` bytes, in `utf8mb4` charset, it's `3072 / 4 = 768`
// characters 18 + 125 * 6 = 768
.col(ColumnDef::new(CasbinRule::Ptype).string_len(18).not_null())
.col(ColumnDef::new(CasbinRule::V0).string_len(125).not_null())
.col(ColumnDef::new(CasbinRule::V1).string_len(125).not_null())
.col(ColumnDef::new(CasbinRule::V2).string_len(125).not_null())
.col(ColumnDef::new(CasbinRule::V3).string_len(125).not_null())
.col(ColumnDef::new(CasbinRule::V4).string_len(125).not_null())
.col(ColumnDef::new(CasbinRule::V5).string_len(125).not_null())
.index(
Index::create()
.name("unique_key_sea_orm_adapter")
.unique()
.table(CasbinRule::Table)
.col(CasbinRule::Ptype)
.col(CasbinRule::V0)
.col(CasbinRule::V1)
.col(CasbinRule::V2)
.col(CasbinRule::V3)
.col(CasbinRule::V4)
.col(CasbinRule::V5),
)
.to_owned();
let builder = conn.get_database_backend();
conn.execute(builder.build(&create_table)).await
}
pub async fn down<C: ConnectionTrait>(conn: &C) -> Result<ExecResult, DbErr> {
let drop_table = Table::drop()
.if_exists()
.table(CasbinRule::Table)
.to_owned();
let builder = conn.get_database_backend();
conn.execute(builder.build(&drop_table)).await
}
| rust | Apache-2.0 | a560191ee087ba509e2060f17937b9f2c8f9be33 | 2026-01-04T20:21:43.261270Z | false |
soybeanjs/soybean-admin-rust | https://github.com/soybeanjs/soybean-admin-rust/blob/a560191ee087ba509e2060f17937b9f2c8f9be33/migration/src/lib.rs | migration/src/lib.rs | pub use sea_orm_migration::prelude::*;
mod datas;
mod schemas;
pub struct Migrator;
#[async_trait::async_trait]
impl MigratorTrait for Migrator {
fn migrations() -> Vec<Box<dyn MigrationTrait>> {
vec![
// 架构迁移
Box::new(schemas::m20240815_082808_create_enum_status::Migration),
Box::new(schemas::m20240815_082854_create_sys_user::Migration),
Box::new(schemas::m20241023_091143_create_sys_menu::Migration),
Box::new(schemas::m20241023_091155_create_sys_organization::Migration),
Box::new(schemas::m20241023_091109_create_sys_access_key::Migration),
Box::new(schemas::m20241023_091115_create_sys_domain::Migration),
Box::new(schemas::m20241023_091132_create_sys_endpoint::Migration),
Box::new(schemas::m20241023_091138_create_sys_login_log::Migration),
Box::new(schemas::m20241023_091149_create_sys_operation_log::Migration),
Box::new(schemas::m20241023_090604_create_sys_role::Migration),
Box::new(schemas::m20241023_091204_create_sys_tokens::Migration),
Box::new(schemas::m20241023_091210_create_sys_user_role::Migration),
Box::new(schemas::m20241023_091159_create_sys_role_menu::Migration),
// 数据迁移
Box::new(datas::m20241023_102950_insert_sys_domain::Migration),
Box::new(datas::m20241024_033005_insert_sys_user::Migration),
Box::new(datas::m20241024_034526_insert_sys_role::Migration),
Box::new(datas::m20241024_034744_insert_sys_menu::Migration),
Box::new(datas::m20241024_033933_insert_sys_user_role::Migration),
Box::new(datas::m20241024_034305_insert_sys_role_menu::Migration),
Box::new(datas::m20241024_082926_insert_casbin_rule::Migration),
]
}
}
| rust | Apache-2.0 | a560191ee087ba509e2060f17937b9f2c8f9be33 | 2026-01-04T20:21:43.261270Z | false |
soybeanjs/soybean-admin-rust | https://github.com/soybeanjs/soybean-admin-rust/blob/a560191ee087ba509e2060f17937b9f2c8f9be33/migration/src/main.rs | migration/src/main.rs | use sea_orm_migration::prelude::*;
#[async_std::main]
async fn main() {
cli::run_cli(migration::Migrator).await;
}
| rust | Apache-2.0 | a560191ee087ba509e2060f17937b9f2c8f9be33 | 2026-01-04T20:21:43.261270Z | false |
soybeanjs/soybean-admin-rust | https://github.com/soybeanjs/soybean-admin-rust/blob/a560191ee087ba509e2060f17937b9f2c8f9be33/migration/src/schemas/m20241023_091204_create_sys_tokens.rs | migration/src/schemas/m20241023_091204_create_sys_tokens.rs | use sea_orm_migration::prelude::*;
#[derive(DeriveMigrationName)]
pub struct Migration;
#[async_trait::async_trait]
impl MigrationTrait for Migration {
async fn up(&self, manager: &SchemaManager) -> Result<(), DbErr> {
manager
.create_table(
Table::create()
.table(SysTokens::Table)
.if_not_exists()
.col(
ColumnDef::new(SysTokens::Id)
.string()
.not_null()
.primary_key(),
)
.col(ColumnDef::new(SysTokens::AccessToken).string().not_null())
.col(ColumnDef::new(SysTokens::RefreshToken).string().not_null())
.col(ColumnDef::new(SysTokens::Status).string().not_null())
.col(ColumnDef::new(SysTokens::UserId).string().not_null())
.col(ColumnDef::new(SysTokens::Username).string().not_null())
.col(ColumnDef::new(SysTokens::Domain).string().not_null())
.col(ColumnDef::new(SysTokens::LoginTime).timestamp().not_null())
.col(ColumnDef::new(SysTokens::Ip).string().not_null())
.col(ColumnDef::new(SysTokens::Port).integer().null())
.col(ColumnDef::new(SysTokens::Address).string().not_null())
.col(ColumnDef::new(SysTokens::UserAgent).string().not_null())
.col(ColumnDef::new(SysTokens::RequestId).string().not_null())
.col(ColumnDef::new(SysTokens::Type).string().not_null())
.col(
ColumnDef::new(SysTokens::CreatedAt)
.timestamp()
.not_null()
.default(Expr::current_timestamp()),
)
.col(ColumnDef::new(SysTokens::CreatedBy).string().not_null())
.to_owned(),
)
.await
}
async fn down(&self, manager: &SchemaManager) -> Result<(), DbErr> {
manager
.drop_table(Table::drop().table(SysTokens::Table).to_owned())
.await
}
}
#[derive(DeriveIden)]
enum SysTokens {
Table,
Id,
AccessToken,
RefreshToken,
Status,
UserId,
Username,
Domain,
LoginTime,
Ip,
Port,
Address,
UserAgent,
RequestId,
Type,
CreatedAt,
CreatedBy,
}
| rust | Apache-2.0 | a560191ee087ba509e2060f17937b9f2c8f9be33 | 2026-01-04T20:21:43.261270Z | false |
soybeanjs/soybean-admin-rust | https://github.com/soybeanjs/soybean-admin-rust/blob/a560191ee087ba509e2060f17937b9f2c8f9be33/migration/src/schemas/m20241023_091149_create_sys_operation_log.rs | migration/src/schemas/m20241023_091149_create_sys_operation_log.rs | use sea_orm_migration::prelude::*;
#[derive(DeriveMigrationName)]
pub struct Migration;
#[async_trait::async_trait]
impl MigrationTrait for Migration {
async fn up(&self, manager: &SchemaManager) -> Result<(), DbErr> {
manager
.create_table(
Table::create()
.table(SysOperationLog::Table)
.if_not_exists()
.col(
ColumnDef::new(SysOperationLog::Id)
.string()
.not_null()
.primary_key(),
)
.col(ColumnDef::new(SysOperationLog::UserId).string().not_null())
.col(
ColumnDef::new(SysOperationLog::Username)
.string()
.not_null(),
)
.col(ColumnDef::new(SysOperationLog::Domain).string().not_null())
.col(
ColumnDef::new(SysOperationLog::ModuleName)
.string()
.not_null(),
)
.col(
ColumnDef::new(SysOperationLog::Description)
.string()
.not_null(),
)
.col(
ColumnDef::new(SysOperationLog::RequestId)
.string()
.not_null(),
)
.col(ColumnDef::new(SysOperationLog::Method).string().not_null())
.col(ColumnDef::new(SysOperationLog::Url).string().not_null())
.col(ColumnDef::new(SysOperationLog::Ip).string().not_null())
.col(ColumnDef::new(SysOperationLog::UserAgent).string().null())
.col(ColumnDef::new(SysOperationLog::Params).json_binary().null())
.col(ColumnDef::new(SysOperationLog::Body).json_binary().null())
.col(
ColumnDef::new(SysOperationLog::Response)
.json_binary()
.null(),
)
.col(
ColumnDef::new(SysOperationLog::StartTime)
.timestamp()
.not_null(),
)
.col(
ColumnDef::new(SysOperationLog::EndTime)
.timestamp()
.not_null(),
)
.col(
ColumnDef::new(SysOperationLog::Duration)
.integer()
.not_null(),
)
.col(
ColumnDef::new(SysOperationLog::CreatedAt)
.timestamp()
.not_null()
.default(Expr::current_timestamp()),
)
.to_owned(),
)
.await
}
async fn down(&self, manager: &SchemaManager) -> Result<(), DbErr> {
manager
.drop_table(Table::drop().table(SysOperationLog::Table).to_owned())
.await
}
}
#[derive(DeriveIden)]
enum SysOperationLog {
Table,
Id,
UserId,
Username,
Domain,
ModuleName,
Description,
RequestId,
Method,
Url,
Ip,
UserAgent,
Params,
Body,
Response,
StartTime,
EndTime,
Duration,
CreatedAt,
}
| rust | Apache-2.0 | a560191ee087ba509e2060f17937b9f2c8f9be33 | 2026-01-04T20:21:43.261270Z | false |
soybeanjs/soybean-admin-rust | https://github.com/soybeanjs/soybean-admin-rust/blob/a560191ee087ba509e2060f17937b9f2c8f9be33/migration/src/schemas/m20241023_091143_create_sys_menu.rs | migration/src/schemas/m20241023_091143_create_sys_menu.rs | use sea_orm::Iterable;
use sea_orm_migration::prelude::*;
use super::m20240815_082808_create_enum_status::{MenuType, Status};
#[derive(DeriveMigrationName)]
pub struct Migration;
#[async_trait::async_trait]
impl MigrationTrait for Migration {
async fn up(&self, manager: &SchemaManager) -> Result<(), DbErr> {
manager
.create_table(
Table::create()
.table(SysMenu::Table)
.if_not_exists()
.col(
ColumnDef::new(SysMenu::Id)
.integer()
.not_null()
.auto_increment()
.primary_key(),
)
.col(
ColumnDef::new(SysMenu::MenuType)
.enumeration(Alias::new("menu_type"), MenuType::iter())
.not_null(),
)
.col(ColumnDef::new(SysMenu::MenuName).string().not_null())
.col(ColumnDef::new(SysMenu::IconType).integer().null())
.col(ColumnDef::new(SysMenu::Icon).string().null())
.col(
ColumnDef::new(SysMenu::RouteName)
.string()
.not_null()
.unique_key(),
)
.col(ColumnDef::new(SysMenu::RoutePath).string().not_null())
.col(ColumnDef::new(SysMenu::Component).string().not_null())
.col(ColumnDef::new(SysMenu::PathParam).string().null())
.col(
ColumnDef::new(SysMenu::Status)
.enumeration(Alias::new("status"), Status::iter())
.not_null(),
)
.col(ColumnDef::new(SysMenu::ActiveMenu).string().null())
.col(ColumnDef::new(SysMenu::HideInMenu).boolean().null())
.col(ColumnDef::new(SysMenu::Pid).string().not_null())
.col(ColumnDef::new(SysMenu::Sequence).integer().not_null())
.col(ColumnDef::new(SysMenu::I18nKey).string().null())
.col(ColumnDef::new(SysMenu::KeepAlive).boolean().null())
.col(ColumnDef::new(SysMenu::Constant).boolean().not_null())
.col(ColumnDef::new(SysMenu::Href).string().null())
.col(ColumnDef::new(SysMenu::MultiTab).boolean().null())
.col(
ColumnDef::new(SysMenu::CreatedAt)
.timestamp()
.not_null()
.default(Expr::current_timestamp()),
)
.col(ColumnDef::new(SysMenu::CreatedBy).string().not_null())
.col(ColumnDef::new(SysMenu::UpdatedAt).timestamp().null())
.col(ColumnDef::new(SysMenu::UpdatedBy).string().null())
.to_owned(),
)
.await
}
async fn down(&self, manager: &SchemaManager) -> Result<(), DbErr> {
manager
.drop_table(Table::drop().table(SysMenu::Table).to_owned())
.await
}
}
#[derive(DeriveIden)]
enum SysMenu {
Table,
Id,
MenuType,
MenuName,
IconType,
Icon,
RouteName,
RoutePath,
Component,
PathParam,
Status,
ActiveMenu,
HideInMenu,
Pid,
Sequence,
I18nKey,
KeepAlive,
Constant,
Href,
MultiTab,
CreatedAt,
CreatedBy,
UpdatedAt,
UpdatedBy,
}
| rust | Apache-2.0 | a560191ee087ba509e2060f17937b9f2c8f9be33 | 2026-01-04T20:21:43.261270Z | false |
soybeanjs/soybean-admin-rust | https://github.com/soybeanjs/soybean-admin-rust/blob/a560191ee087ba509e2060f17937b9f2c8f9be33/migration/src/schemas/m20241023_091109_create_sys_access_key.rs | migration/src/schemas/m20241023_091109_create_sys_access_key.rs | use sea_orm::Iterable;
use sea_orm_migration::prelude::*;
use super::m20240815_082808_create_enum_status::Status;
#[derive(DeriveMigrationName)]
pub struct Migration;
#[async_trait::async_trait]
impl MigrationTrait for Migration {
async fn up(&self, manager: &SchemaManager) -> Result<(), DbErr> {
manager
.create_table(
Table::create()
.table(SysAccessKey::Table)
.if_not_exists()
.col(
ColumnDef::new(SysAccessKey::Id)
.string()
.not_null()
.primary_key(),
)
.col(ColumnDef::new(SysAccessKey::Domain).string().not_null())
.col(
ColumnDef::new(SysAccessKey::AccessKeyId)
.string()
.not_null()
.unique_key(),
)
.col(
ColumnDef::new(SysAccessKey::AccessKeySecret)
.string()
.not_null()
.unique_key(),
)
.col(
ColumnDef::new(SysAccessKey::Status)
.enumeration(Alias::new("status"), Status::iter())
.not_null(),
)
.col(ColumnDef::new(SysAccessKey::Description).string().null())
.col(
ColumnDef::new(SysAccessKey::CreatedAt)
.timestamp()
.not_null()
.default(Expr::current_timestamp()),
)
.col(ColumnDef::new(SysAccessKey::CreatedBy).string().not_null())
.to_owned(),
)
.await
}
async fn down(&self, manager: &SchemaManager) -> Result<(), DbErr> {
manager
.drop_table(Table::drop().table(SysAccessKey::Table).to_owned())
.await
}
}
#[derive(DeriveIden)]
enum SysAccessKey {
Table,
Id,
Domain,
AccessKeyId,
AccessKeySecret,
Status,
Description,
CreatedAt,
CreatedBy,
}
| rust | Apache-2.0 | a560191ee087ba509e2060f17937b9f2c8f9be33 | 2026-01-04T20:21:43.261270Z | false |
soybeanjs/soybean-admin-rust | https://github.com/soybeanjs/soybean-admin-rust/blob/a560191ee087ba509e2060f17937b9f2c8f9be33/migration/src/schemas/m20241023_090604_create_sys_role.rs | migration/src/schemas/m20241023_090604_create_sys_role.rs | use sea_orm::Iterable;
use sea_orm_migration::prelude::*;
use super::m20240815_082808_create_enum_status::Status;
#[derive(DeriveMigrationName)]
pub struct Migration;
#[async_trait::async_trait]
impl MigrationTrait for Migration {
async fn up(&self, manager: &SchemaManager) -> Result<(), DbErr> {
manager
.create_table(
Table::create()
.table(SysRole::Table)
.if_not_exists()
.col(
ColumnDef::new(SysRole::Id)
.string()
.not_null()
.primary_key(),
)
.col(
ColumnDef::new(SysRole::Code)
.string()
.not_null()
.unique_key(),
)
.col(ColumnDef::new(SysRole::Name).string().not_null())
.col(ColumnDef::new(SysRole::Description).string().null())
.col(ColumnDef::new(SysRole::Pid).string().not_null())
.col(
ColumnDef::new(SysRole::Status)
.enumeration(Alias::new("status"), Status::iter())
.not_null(),
)
.col(
ColumnDef::new(SysRole::CreatedAt)
.timestamp()
.not_null()
.default(Expr::current_timestamp()),
)
.col(ColumnDef::new(SysRole::CreatedBy).string().not_null())
.col(ColumnDef::new(SysRole::UpdatedAt).timestamp().null())
.col(ColumnDef::new(SysRole::UpdatedBy).string().null())
.to_owned(),
)
.await
}
async fn down(&self, manager: &SchemaManager) -> Result<(), DbErr> {
manager
.drop_table(Table::drop().table(SysRole::Table).to_owned())
.await
}
}
#[derive(DeriveIden)]
enum SysRole {
Table,
Id,
Code,
Name,
Description,
Pid,
Status,
CreatedAt,
CreatedBy,
UpdatedAt,
UpdatedBy,
}
| rust | Apache-2.0 | a560191ee087ba509e2060f17937b9f2c8f9be33 | 2026-01-04T20:21:43.261270Z | false |
soybeanjs/soybean-admin-rust | https://github.com/soybeanjs/soybean-admin-rust/blob/a560191ee087ba509e2060f17937b9f2c8f9be33/migration/src/schemas/m20241023_091210_create_sys_user_role.rs | migration/src/schemas/m20241023_091210_create_sys_user_role.rs | use sea_orm_migration::prelude::*;
#[derive(DeriveMigrationName)]
pub struct Migration;
#[async_trait::async_trait]
impl MigrationTrait for Migration {
async fn up(&self, manager: &SchemaManager) -> Result<(), DbErr> {
manager
.create_table(
Table::create()
.table(SysUserRole::Table)
.if_not_exists()
.col(ColumnDef::new(SysUserRole::UserId).string().not_null())
.col(ColumnDef::new(SysUserRole::RoleId).string().not_null())
.primary_key(
Index::create()
.col(SysUserRole::UserId)
.col(SysUserRole::RoleId),
)
.to_owned(),
)
.await?;
// Add foreign key constraints
manager
.create_foreign_key(
ForeignKey::create()
.name("fk_sys_user_role_user_id")
.from(SysUserRole::Table, SysUserRole::UserId)
.to(Alias::new("sys_user"), Alias::new("id"))
.to_owned(),
)
.await?;
manager
.create_foreign_key(
ForeignKey::create()
.name("fk_sys_user_role_role_id")
.from(SysUserRole::Table, SysUserRole::RoleId)
.to(Alias::new("sys_role"), Alias::new("id"))
.to_owned(),
)
.await
}
async fn down(&self, manager: &SchemaManager) -> Result<(), DbErr> {
manager
.drop_table(Table::drop().table(SysUserRole::Table).to_owned())
.await
}
}
#[derive(DeriveIden)]
enum SysUserRole {
Table,
UserId,
RoleId,
}
| rust | Apache-2.0 | a560191ee087ba509e2060f17937b9f2c8f9be33 | 2026-01-04T20:21:43.261270Z | false |
soybeanjs/soybean-admin-rust | https://github.com/soybeanjs/soybean-admin-rust/blob/a560191ee087ba509e2060f17937b9f2c8f9be33/migration/src/schemas/m20240815_082808_create_enum_status.rs | migration/src/schemas/m20240815_082808_create_enum_status.rs | use sea_orm::EnumIter;
use sea_orm_migration::{
prelude::{sea_query::extension::postgres::Type, *},
sea_orm::{ConnectionTrait, DbBackend},
};
#[derive(DeriveMigrationName)]
pub struct Migration;
#[async_trait::async_trait]
impl MigrationTrait for Migration {
async fn up(&self, manager: &SchemaManager) -> Result<(), DbErr> {
let db = manager.get_connection();
match db.get_database_backend() {
DbBackend::MySql | DbBackend::Sqlite => {},
DbBackend::Postgres => {
// Create status enum
manager
.create_type(
Type::create()
.as_enum(Alias::new("status"))
.values([Status::Enabled, Status::Disabled, Status::Banned])
.to_owned(),
)
.await?;
// Create menu_type enum
manager
.create_type(
Type::create()
.as_enum(Alias::new("menu_type"))
.values([MenuType::Directory, MenuType::Menu])
.to_owned(),
)
.await?;
},
}
Ok(())
}
async fn down(&self, manager: &SchemaManager) -> Result<(), DbErr> {
let db = manager.get_connection();
match db.get_database_backend() {
DbBackend::MySql | DbBackend::Sqlite => {},
DbBackend::Postgres => {
// Drop status enum
manager
.drop_type(Type::drop().name(Alias::new("status")).to_owned())
.await?;
// Drop menu_type enum
manager
.drop_type(Type::drop().name(Alias::new("menu_type")).to_owned())
.await?;
},
}
Ok(())
}
}
#[derive(DeriveIden, EnumIter)]
pub enum Status {
#[sea_orm(iden = "status")]
Enum,
#[sea_orm(iden = "enabled")]
Enabled,
#[sea_orm(iden = "disabled")]
Disabled,
#[sea_orm(iden = "banned")]
Banned,
}
#[derive(DeriveIden, EnumIter)]
pub enum MenuType {
#[sea_orm(iden = "menu_type")]
Enum,
#[sea_orm(iden = "directory")]
Directory,
#[sea_orm(iden = "menu")]
Menu,
}
| rust | Apache-2.0 | a560191ee087ba509e2060f17937b9f2c8f9be33 | 2026-01-04T20:21:43.261270Z | false |
soybeanjs/soybean-admin-rust | https://github.com/soybeanjs/soybean-admin-rust/blob/a560191ee087ba509e2060f17937b9f2c8f9be33/migration/src/schemas/m20241023_091138_create_sys_login_log.rs | migration/src/schemas/m20241023_091138_create_sys_login_log.rs | use sea_orm_migration::prelude::*;
#[derive(DeriveMigrationName)]
pub struct Migration;
#[async_trait::async_trait]
impl MigrationTrait for Migration {
async fn up(&self, manager: &SchemaManager) -> Result<(), DbErr> {
manager
.create_table(
Table::create()
.table(SysLoginLog::Table)
.if_not_exists()
.col(
ColumnDef::new(SysLoginLog::Id)
.string()
.not_null()
.primary_key(),
)
.col(ColumnDef::new(SysLoginLog::UserId).string().not_null())
.col(ColumnDef::new(SysLoginLog::Username).string().not_null())
.col(ColumnDef::new(SysLoginLog::Domain).string().not_null())
.col(
ColumnDef::new(SysLoginLog::LoginTime)
.timestamp()
.not_null(),
)
.col(ColumnDef::new(SysLoginLog::Ip).string().not_null())
.col(ColumnDef::new(SysLoginLog::Port).integer().null())
.col(ColumnDef::new(SysLoginLog::Address).string().not_null())
.col(ColumnDef::new(SysLoginLog::UserAgent).string().not_null())
.col(ColumnDef::new(SysLoginLog::RequestId).string().not_null())
.col(ColumnDef::new(SysLoginLog::Type).string().not_null())
.col(
ColumnDef::new(SysLoginLog::CreatedAt)
.timestamp()
.not_null()
.default(Expr::current_timestamp()),
)
.col(ColumnDef::new(SysLoginLog::CreatedBy).string().not_null())
.to_owned(),
)
.await
}
async fn down(&self, manager: &SchemaManager) -> Result<(), DbErr> {
manager
.drop_table(Table::drop().table(SysLoginLog::Table).to_owned())
.await
}
}
#[derive(DeriveIden)]
enum SysLoginLog {
Table,
Id,
UserId,
Username,
Domain,
LoginTime,
Ip,
Port,
Address,
UserAgent,
RequestId,
Type,
CreatedAt,
CreatedBy,
}
| rust | Apache-2.0 | a560191ee087ba509e2060f17937b9f2c8f9be33 | 2026-01-04T20:21:43.261270Z | false |
soybeanjs/soybean-admin-rust | https://github.com/soybeanjs/soybean-admin-rust/blob/a560191ee087ba509e2060f17937b9f2c8f9be33/migration/src/schemas/m20240815_082854_create_sys_user.rs | migration/src/schemas/m20240815_082854_create_sys_user.rs | use sea_orm::Iterable;
use sea_orm_migration::prelude::*;
use super::m20240815_082808_create_enum_status::Status;
#[derive(DeriveMigrationName)]
pub struct Migration;
#[async_trait::async_trait]
impl MigrationTrait for Migration {
async fn up(&self, manager: &SchemaManager) -> Result<(), DbErr> {
// 创建表
manager
.create_table(
Table::create()
.table(SysUser::Table)
.if_not_exists()
.col(
ColumnDef::new(SysUser::Id)
.string()
.not_null()
.primary_key(),
)
.col(
ColumnDef::new(SysUser::Username)
.string()
.not_null()
.unique_key()
.comment("用户名"),
)
.col(
ColumnDef::new(SysUser::Password)
.string()
.not_null()
.comment("密码"),
)
.col(
ColumnDef::new(SysUser::Domain)
.string()
.not_null()
.comment("域"),
)
.col(
ColumnDef::new(SysUser::BuiltIn)
.boolean()
.not_null()
.comment("是否内置"),
)
.col(ColumnDef::new(SysUser::Avatar).string().comment("头像"))
.col(
ColumnDef::new(SysUser::Email)
.string()
.unique_key()
.comment("邮箱"),
)
.col(
ColumnDef::new(SysUser::PhoneNumber)
.string()
.unique_key()
.comment("手机号"),
)
.col(
ColumnDef::new(SysUser::NickName)
.string()
.not_null()
.comment("昵称"),
)
.col(
ColumnDef::new(SysUser::Status)
.enumeration(Alias::new("status"), Status::iter())
.not_null()
.comment("用户状态"),
)
.col(
ColumnDef::new(SysUser::CreatedAt)
.timestamp()
.not_null()
.default(Expr::current_timestamp())
.comment("创建时间"),
)
.col(ColumnDef::new(SysUser::CreatedBy).string().not_null())
.col(ColumnDef::new(SysUser::UpdatedAt).timestamp())
.col(ColumnDef::new(SysUser::UpdatedBy).string())
.to_owned(),
)
.await?;
// 创建索引
manager
.create_index(
Index::create()
.table(SysUser::Table)
.name("idx_sys_user_domain_id")
.col(SysUser::Domain)
.to_owned(),
)
.await?;
manager
.create_index(
Index::create()
.table(SysUser::Table)
.name("idx_sys_user_username")
.col(SysUser::Username)
.unique()
.to_owned(),
)
.await?;
Ok(())
}
async fn down(&self, manager: &SchemaManager) -> Result<(), DbErr> {
manager
.drop_table(Table::drop().table(SysUser::Table).to_owned())
.await
}
}
#[derive(DeriveIden)]
pub enum SysUser {
Table,
Id,
Username,
Password,
Domain,
BuiltIn,
Avatar,
Email,
PhoneNumber,
NickName,
Status,
CreatedAt,
CreatedBy,
UpdatedAt,
UpdatedBy,
}
| rust | Apache-2.0 | a560191ee087ba509e2060f17937b9f2c8f9be33 | 2026-01-04T20:21:43.261270Z | false |
soybeanjs/soybean-admin-rust | https://github.com/soybeanjs/soybean-admin-rust/blob/a560191ee087ba509e2060f17937b9f2c8f9be33/migration/src/schemas/m20241023_091132_create_sys_endpoint.rs | migration/src/schemas/m20241023_091132_create_sys_endpoint.rs | use sea_orm_migration::prelude::*;
#[derive(DeriveMigrationName)]
pub struct Migration;
#[async_trait::async_trait]
impl MigrationTrait for Migration {
async fn up(&self, manager: &SchemaManager) -> Result<(), DbErr> {
manager
.create_table(
Table::create()
.table(SysEndpoint::Table)
.if_not_exists()
.col(
ColumnDef::new(SysEndpoint::Id)
.string()
.not_null()
.primary_key(),
)
.col(ColumnDef::new(SysEndpoint::Path).string().not_null())
.col(ColumnDef::new(SysEndpoint::Method).string().not_null())
.col(ColumnDef::new(SysEndpoint::Action).string().not_null())
.col(ColumnDef::new(SysEndpoint::Resource).string().not_null())
.col(ColumnDef::new(SysEndpoint::Controller).string().not_null())
.col(ColumnDef::new(SysEndpoint::Summary).string().null())
.col(
ColumnDef::new(SysEndpoint::CreatedAt)
.timestamp()
.not_null()
.default(Expr::current_timestamp()),
)
.col(ColumnDef::new(SysEndpoint::UpdatedAt).timestamp().null())
.to_owned(),
)
.await
}
async fn down(&self, manager: &SchemaManager) -> Result<(), DbErr> {
manager
.drop_table(Table::drop().table(SysEndpoint::Table).to_owned())
.await
}
}
#[derive(DeriveIden)]
enum SysEndpoint {
Table,
Id,
Path,
Method,
Action,
Resource,
Controller,
Summary,
CreatedAt,
UpdatedAt,
}
| rust | Apache-2.0 | a560191ee087ba509e2060f17937b9f2c8f9be33 | 2026-01-04T20:21:43.261270Z | false |
soybeanjs/soybean-admin-rust | https://github.com/soybeanjs/soybean-admin-rust/blob/a560191ee087ba509e2060f17937b9f2c8f9be33/migration/src/schemas/mod.rs | migration/src/schemas/mod.rs | pub mod m20240815_082808_create_enum_status;
pub mod m20240815_082854_create_sys_user;
pub mod m20241023_090604_create_sys_role;
pub mod m20241023_091109_create_sys_access_key;
pub mod m20241023_091115_create_sys_domain;
pub mod m20241023_091132_create_sys_endpoint;
pub mod m20241023_091138_create_sys_login_log;
pub mod m20241023_091143_create_sys_menu;
pub mod m20241023_091149_create_sys_operation_log;
pub mod m20241023_091155_create_sys_organization;
pub mod m20241023_091159_create_sys_role_menu;
pub mod m20241023_091204_create_sys_tokens;
pub mod m20241023_091210_create_sys_user_role;
| rust | Apache-2.0 | a560191ee087ba509e2060f17937b9f2c8f9be33 | 2026-01-04T20:21:43.261270Z | false |
soybeanjs/soybean-admin-rust | https://github.com/soybeanjs/soybean-admin-rust/blob/a560191ee087ba509e2060f17937b9f2c8f9be33/migration/src/schemas/m20241023_091159_create_sys_role_menu.rs | migration/src/schemas/m20241023_091159_create_sys_role_menu.rs | use sea_orm_migration::prelude::*;
#[derive(DeriveMigrationName)]
pub struct Migration;
#[async_trait::async_trait]
impl MigrationTrait for Migration {
async fn up(&self, manager: &SchemaManager) -> Result<(), DbErr> {
manager
.create_table(
Table::create()
.table(SysRoleMenu::Table)
.if_not_exists()
.col(ColumnDef::new(SysRoleMenu::RoleId).string().not_null())
.col(ColumnDef::new(SysRoleMenu::MenuId).integer().not_null())
.col(ColumnDef::new(SysRoleMenu::Domain).string().not_null())
.primary_key(
Index::create()
.col(SysRoleMenu::RoleId)
.col(SysRoleMenu::MenuId)
.col(SysRoleMenu::Domain),
)
.to_owned(),
)
.await
}
async fn down(&self, manager: &SchemaManager) -> Result<(), DbErr> {
manager
.drop_table(Table::drop().table(SysRoleMenu::Table).to_owned())
.await
}
}
#[derive(DeriveIden)]
enum SysRoleMenu {
Table,
RoleId,
MenuId,
Domain,
}
| rust | Apache-2.0 | a560191ee087ba509e2060f17937b9f2c8f9be33 | 2026-01-04T20:21:43.261270Z | false |
soybeanjs/soybean-admin-rust | https://github.com/soybeanjs/soybean-admin-rust/blob/a560191ee087ba509e2060f17937b9f2c8f9be33/migration/src/schemas/m20241023_091115_create_sys_domain.rs | migration/src/schemas/m20241023_091115_create_sys_domain.rs | use sea_orm::Iterable;
use sea_orm_migration::prelude::*;
use super::m20240815_082808_create_enum_status::Status;
#[derive(DeriveMigrationName)]
pub struct Migration;
#[async_trait::async_trait]
impl MigrationTrait for Migration {
async fn up(&self, manager: &SchemaManager) -> Result<(), DbErr> {
manager
.create_table(
Table::create()
.table(SysDomain::Table)
.if_not_exists()
.col(
ColumnDef::new(SysDomain::Id)
.string()
.not_null()
.primary_key(),
)
.col(
ColumnDef::new(SysDomain::Code)
.string()
.not_null()
.unique_key(),
)
.col(ColumnDef::new(SysDomain::Name).string().not_null())
.col(ColumnDef::new(SysDomain::Description).string().null())
.col(
ColumnDef::new(SysDomain::Status)
.enumeration(Alias::new("status"), Status::iter())
.not_null(),
)
.col(
ColumnDef::new(SysDomain::CreatedAt)
.timestamp()
.not_null()
.default(Expr::current_timestamp()),
)
.col(ColumnDef::new(SysDomain::CreatedBy).string().not_null())
.col(ColumnDef::new(SysDomain::UpdatedAt).timestamp().null())
.col(ColumnDef::new(SysDomain::UpdatedBy).string().null())
.to_owned(),
)
.await
}
async fn down(&self, manager: &SchemaManager) -> Result<(), DbErr> {
manager
.drop_table(Table::drop().table(SysDomain::Table).to_owned())
.await
}
}
#[derive(DeriveIden)]
enum SysDomain {
Table,
Id,
Code,
Name,
Description,
Status,
CreatedAt,
CreatedBy,
UpdatedAt,
UpdatedBy,
}
| rust | Apache-2.0 | a560191ee087ba509e2060f17937b9f2c8f9be33 | 2026-01-04T20:21:43.261270Z | false |
soybeanjs/soybean-admin-rust | https://github.com/soybeanjs/soybean-admin-rust/blob/a560191ee087ba509e2060f17937b9f2c8f9be33/migration/src/schemas/m20241023_091155_create_sys_organization.rs | migration/src/schemas/m20241023_091155_create_sys_organization.rs | use sea_orm::Iterable;
use sea_orm_migration::prelude::*;
use super::m20240815_082808_create_enum_status::Status;
#[derive(DeriveMigrationName)]
pub struct Migration;
#[async_trait::async_trait]
impl MigrationTrait for Migration {
async fn up(&self, manager: &SchemaManager) -> Result<(), DbErr> {
manager
.create_table(
Table::create()
.table(SysOrganization::Table)
.if_not_exists()
.col(
ColumnDef::new(SysOrganization::Id)
.string()
.not_null()
.primary_key(),
)
.col(
ColumnDef::new(SysOrganization::Code)
.string()
.not_null()
.unique_key(),
)
.col(ColumnDef::new(SysOrganization::Name).string().not_null())
.col(ColumnDef::new(SysOrganization::Description).string().null())
.col(ColumnDef::new(SysOrganization::Pid).string().not_null())
.col(
ColumnDef::new(SysOrganization::Status)
.enumeration(Alias::new("status"), Status::iter())
.not_null(),
)
.col(
ColumnDef::new(SysOrganization::CreatedAt)
.timestamp()
.not_null()
.default(Expr::current_timestamp()),
)
.col(
ColumnDef::new(SysOrganization::CreatedBy)
.string()
.not_null(),
)
.col(
ColumnDef::new(SysOrganization::UpdatedAt)
.timestamp()
.null(),
)
.col(ColumnDef::new(SysOrganization::UpdatedBy).string().null())
.to_owned(),
)
.await
}
async fn down(&self, manager: &SchemaManager) -> Result<(), DbErr> {
manager
.drop_table(Table::drop().table(SysOrganization::Table).to_owned())
.await
}
}
#[derive(DeriveIden)]
enum SysOrganization {
Table,
Id,
Code,
Name,
Description,
Pid,
Status,
CreatedAt,
CreatedBy,
UpdatedAt,
UpdatedBy,
}
| rust | Apache-2.0 | a560191ee087ba509e2060f17937b9f2c8f9be33 | 2026-01-04T20:21:43.261270Z | false |
soybeanjs/soybean-admin-rust | https://github.com/soybeanjs/soybean-admin-rust/blob/a560191ee087ba509e2060f17937b9f2c8f9be33/migration/src/datas/m20241024_082926_insert_casbin_rule.rs | migration/src/datas/m20241024_082926_insert_casbin_rule.rs | use sea_orm_migration::{prelude::*, sea_orm::Statement};
#[derive(DeriveMigrationName)]
pub struct Migration;
#[async_trait::async_trait]
impl MigrationTrait for Migration {
async fn up(&self, manager: &SchemaManager) -> Result<(), DbErr> {
let db = manager.get_connection();
// 执行架构迁移
sea_orm_adapter::up(db).await?;
let insert_casbin_rules_stmt = Statement::from_string(
manager.get_database_backend(),
r#"
INSERT INTO casbin_rule (ptype, v0, v1, v2, v3, v4, v5)
VALUES
('p', 'ROLE_SUPER', 'built-in', '/domain', 'GET', '', ''),
('p', 'ROLE_SUPER', 'built-in', '/domain', 'POST', '', ''),
('p', 'ROLE_SUPER', 'built-in', '/domain/:id', 'GET', '', ''),
('p', 'ROLE_SUPER', 'built-in', '/domain', 'PUT', '', ''),
('p', 'ROLE_SUPER', 'built-in', '/domain/:id', 'DELETE', '', ''),
('p', 'ROLE_SUPER', 'built-in', '/route', 'GET', '', ''),
('p', 'ROLE_SUPER', 'built-in', '/route', 'POST', '', ''),
('p', 'ROLE_SUPER', 'built-in', '/route/:id', 'GET', '', ''),
('p', 'ROLE_SUPER', 'built-in', '/route', 'PUT', '', ''),
('p', 'ROLE_SUPER', 'built-in', '/route/:id', 'DELETE', '', ''),
('p', 'ROLE_SUPER', 'built-in', '/route/tree', 'GET', '', ''),
('p', 'ROLE_SUPER', 'built-in', '/route/auth-route/:roleId', 'GET', '', ''),
('p', 'ROLE_SUPER', 'built-in', '/role', 'GET', '', ''),
('p', 'ROLE_SUPER', 'built-in', '/role', 'POST', '', ''),
('p', 'ROLE_SUPER', 'built-in', '/role/:id', 'GET', '', ''),
('p', 'ROLE_SUPER', 'built-in', '/role', 'PUT', '', ''),
('p', 'ROLE_SUPER', 'built-in', '/role/:id', 'DELETE', '', ''),
('p', 'ROLE_SUPER', 'built-in', '/user/users', 'GET', '', ''),
('p', 'ROLE_SUPER', 'built-in', '/user', 'GET', '', ''),
('p', 'ROLE_SUPER', 'built-in', '/user', 'POST', '', ''),
('p', 'ROLE_SUPER', 'built-in', '/user/:id', 'GET', '', ''),
('p', 'ROLE_SUPER', 'built-in', '/user', 'PUT', '', ''),
('p', 'ROLE_SUPER', 'built-in', '/user/:id', 'DELETE', '', ''),
('p', 'ROLE_SUPER', 'built-in', '/api-endpoint', 'GET', '', ''),
('p', 'ROLE_SUPER', 'built-in', '/api-endpoint/auth-api-endpoint/:roleCode', 'GET', '', ''),
('p', 'ROLE_SUPER', 'built-in', '/api-endpoint/tree', 'GET', '', ''),
('p', 'ROLE_SUPER', 'built-in', '/access-key', 'GET', '', ''),
('p', 'ROLE_SUPER', 'built-in', '/access-key', 'POST', '', ''),
('p', 'ROLE_SUPER', 'built-in', '/access-key/:id', 'DELETE', '', ''),
('p', 'ROLE_SUPER', 'built-in', '/login-log', 'GET', '', ''),
('p', 'ROLE_SUPER', 'built-in', '/operation-log', 'GET', '', ''),
('p', 'ROLE_SUPER', 'built-in', '/authorization/assign-permission', 'POST', '', ''),
('p', 'ROLE_SUPER', 'built-in', '/authorization/assign-routes', 'POST', '', '')
"#
.to_string(),
);
db.execute(insert_casbin_rules_stmt).await?;
Ok(())
}
async fn down(&self, manager: &SchemaManager) -> Result<(), DbErr> {
let db = manager.get_connection();
// 删除所有数据并重置序列
let truncate_and_reset_stmt = Statement::from_string(
manager.get_database_backend(),
r#"
TRUNCATE TABLE casbin_rule;
ALTER SEQUENCE casbin_rule_id_seq RESTART WITH 1;
"#
.to_string(),
);
db.execute(truncate_and_reset_stmt).await?;
Ok(())
}
}
| rust | Apache-2.0 | a560191ee087ba509e2060f17937b9f2c8f9be33 | 2026-01-04T20:21:43.261270Z | false |
soybeanjs/soybean-admin-rust | https://github.com/soybeanjs/soybean-admin-rust/blob/a560191ee087ba509e2060f17937b9f2c8f9be33/migration/src/datas/m20241024_033933_insert_sys_user_role.rs | migration/src/datas/m20241024_033933_insert_sys_user_role.rs | use sea_orm_migration::{prelude::*, sea_orm::Statement};
#[derive(DeriveMigrationName)]
pub struct Migration;
#[async_trait::async_trait]
impl MigrationTrait for Migration {
async fn up(&self, manager: &SchemaManager) -> Result<(), DbErr> {
let db = manager.get_connection();
let insert_user_role_stmt = Statement::from_string(
manager.get_database_backend(),
r#"
INSERT INTO sys_user_role (user_id, role_id)
VALUES
('1', '1'),
('2', '2'),
('3', '3')
"#
.to_string(),
);
db.execute(insert_user_role_stmt).await?;
Ok(())
}
async fn down(&self, _manager: &SchemaManager) -> Result<(), DbErr> {
Ok(())
}
}
| rust | Apache-2.0 | a560191ee087ba509e2060f17937b9f2c8f9be33 | 2026-01-04T20:21:43.261270Z | false |
soybeanjs/soybean-admin-rust | https://github.com/soybeanjs/soybean-admin-rust/blob/a560191ee087ba509e2060f17937b9f2c8f9be33/migration/src/datas/m20241024_034526_insert_sys_role.rs | migration/src/datas/m20241024_034526_insert_sys_role.rs | use sea_orm_migration::{prelude::*, sea_orm::Statement};
#[derive(DeriveMigrationName)]
pub struct Migration;
#[async_trait::async_trait]
impl MigrationTrait for Migration {
async fn up(&self, manager: &SchemaManager) -> Result<(), DbErr> {
let db = manager.get_connection();
let insert_role_stmt = Statement::from_string(
manager.get_database_backend(),
r#"
INSERT INTO sys_role (id, code, name, description, pid, status, created_at, created_by, updated_at, updated_by)
VALUES
('1', 'ROLE_SUPER', '超级管理员', '超级管理员', 0, 'enabled', '2024-05-15 00:00:00.000', '-1', NULL, NULL),
('2', 'ROLE_ADMIN', '管理员', '管理员', 1, 'enabled', '2024-05-15 00:00:00.000', '-1', NULL, NULL),
('3', 'ROLE_USER', '用户', '用户', 1, 'enabled', '2024-05-15 00:00:00.000', '-1', NULL, NULL)
"#.to_string(),
);
db.execute(insert_role_stmt).await?;
Ok(())
}
async fn down(&self, _manager: &SchemaManager) -> Result<(), DbErr> {
Ok(())
}
}
| rust | Apache-2.0 | a560191ee087ba509e2060f17937b9f2c8f9be33 | 2026-01-04T20:21:43.261270Z | false |
soybeanjs/soybean-admin-rust | https://github.com/soybeanjs/soybean-admin-rust/blob/a560191ee087ba509e2060f17937b9f2c8f9be33/migration/src/datas/m20241024_034744_insert_sys_menu.rs | migration/src/datas/m20241024_034744_insert_sys_menu.rs | use sea_orm_migration::{prelude::*, sea_orm::Statement};
#[derive(DeriveMigrationName)]
pub struct Migration;
#[async_trait::async_trait]
impl MigrationTrait for Migration {
async fn up(&self, manager: &SchemaManager) -> Result<(), DbErr> {
let db = manager.get_connection();
let insert_menu_stmt = Statement::from_string(
manager.get_database_backend(),
r#"
INSERT INTO sys_menu (id, menu_type, menu_name, icon_type, icon, route_name, route_path, component, path_param, status, active_menu, hide_in_menu, pid, sequence, i18n_key, keep_alive, constant, href, multi_tab, created_at, created_by, updated_at, updated_by)
VALUES
('1', 'menu', 'login', '1', '', 'login', '/login/:module(pwd-login|code-login|register|reset-pwd|bind-wechat)?', 'layout.blank$view.login', '', 'enabled', '', 'true', '0', '0', 'route.login', 'false', 'true', '', 'false', '2024-05-15 00:00:00.000', '-1', NULL, NULL),
('2', 'menu', '403', '1', '', '403', '/403', 'layout.blank$view.403', '', 'enabled', '', 'true', '0', '0', 'route.403', 'false', 'true', '', 'false', '2024-05-15 00:00:00.000', '-1', NULL, NULL),
('3', 'menu', '404', '1', '', '404', '/404', 'layout.blank$view.404', '', 'enabled', '', 'true', '0', '0', 'route.404', 'false', 'true', '', 'false', '2024-05-15 00:00:00.000', '-1', NULL, NULL),
('4', 'menu', '500', '1', '', '500', '/500', 'layout.blank$view.500', '', 'enabled', '', 'true', '0', '0', 'route.500', 'false', 'true', '', 'false', '2024-05-15 00:00:00.000', '-1', NULL, NULL),
('5', 'menu', 'iframe-page', '1', '', 'iframe-page', '/iframe-page/:url', 'layout.base$view.iframe-page', '', 'enabled', '', 'true', '0', '0', 'route.iframe-page', 'false', 'true', '', 'false', '2024-05-15 00:00:00.000', '-1', NULL, NULL),
('62', 'menu', 'manage_menu', '1', 'material-symbols:route', 'manage_menu', '/manage/menu', 'view.manage_menu', '', 'enabled', '', 'false', '54', '2', 'route.manage_menu', 'true', 'false', '', 'false', '2024-05-15 00:00:00.000', '-1', NULL, NULL),
('65', 'menu', 'manage_user-detail', '1', '', 'manage_user-detail', '/manage/user-detail/:id', 'view.manage_user-detail', '', 'enabled', 'manage_user', 'true', '54', '3', 'route.manage_user-detail', 'false', 'false', '', 'false', '2024-05-15 00:00:00.000', '-1', NULL, NULL),
('50', 'menu', 'home', '1', 'mdi:monitor-dashboard', 'home', '/home', 'layout.base$view.home', '', 'enabled', '', 'false', '0', '0', 'route.home', 'false', 'false', '', 'false', '2024-05-15 00:00:00.000', '-1', NULL, NULL),
('54', 'directory', 'manage', '1', 'carbon:cloud-service-management', 'manage', '/manage', 'layout.base', '', 'enabled', '', 'false', '0', '4', 'route.manage', 'false', 'false', '', 'false', '2024-05-15 00:00:00.000', '-1', NULL, NULL),
('64', 'menu', 'manage_user', '1', 'ic:round-manage-accounts', 'manage_user', '/manage/user', 'view.manage_user', '', 'enabled', '', 'false', '54', '0', 'route.manage_user', 'false', 'false', '', 'false', '2024-05-15 00:00:00.000', '-1', NULL, NULL),
('63', 'menu', 'manage_role', '1', 'carbon:user-role', 'manage_role', '/manage/role', 'view.manage_role', '', 'enabled', '', 'false', '54', '1', 'route.manage_role', 'false', 'false', '', 'false', '2024-05-15 00:00:00.000', '-1', NULL, NULL),
('71', 'menu', 'log_login', '1', 'carbon:login', 'log_login', '/log/login', 'view.log_login', '', 'enabled', '', 'false', '52', '0', 'route.log_login', 'false', 'false', '', 'false', '2024-05-15 00:00:00.000', '-1', NULL, NULL),
('72', 'menu', 'log_operation', '1', 'carbon:operations-record', 'log_operation', '/log/operation', 'view.log_operation', '', 'enabled', '', 'false', '52', '0', 'route.log_operation', 'false', 'false', '', 'false', '2024-05-15 00:00:00.000', '-1', NULL, NULL),
('52', 'directory', 'log', '1', 'carbon:cloud-logging', 'log', '/log', 'layout.base', '', 'enabled', '', 'false', '0', '0', 'route.log', 'false', 'false', '', 'false', '2024-05-15 00:00:00.000', '-1', NULL, NULL),
('51', 'menu', 'access-key', '1', 'carbon:document-signed', 'access-key', '/access-key', 'layout.base$view.access-key', '', 'enabled', '', 'false', '0', '0', 'route.access-key', 'false', 'false', '', 'false', '2024-05-15 00:00:00.000', '-1', NULL, NULL)
"#.to_string(),
);
db.execute(insert_menu_stmt).await?;
Ok(())
}
async fn down(&self, _manager: &SchemaManager) -> Result<(), DbErr> {
Ok(())
}
}
| rust | Apache-2.0 | a560191ee087ba509e2060f17937b9f2c8f9be33 | 2026-01-04T20:21:43.261270Z | false |
soybeanjs/soybean-admin-rust | https://github.com/soybeanjs/soybean-admin-rust/blob/a560191ee087ba509e2060f17937b9f2c8f9be33/migration/src/datas/m20241024_033005_insert_sys_user.rs | migration/src/datas/m20241024_033005_insert_sys_user.rs | use sea_orm_migration::{prelude::*, sea_orm::Statement};
#[derive(DeriveMigrationName)]
pub struct Migration;
#[async_trait::async_trait]
impl MigrationTrait for Migration {
async fn up(&self, manager: &SchemaManager) -> Result<(), DbErr> {
let db = manager.get_connection();
let insert_stmt = Statement::from_string(
manager.get_database_backend(),
r#"
INSERT INTO sys_user (id, username, password, domain, built_in, avatar, email, phone_number, nick_name, status, created_at, created_by, updated_at, updated_by)
VALUES
('1', 'Soybean', '$argon2id$v=19$m=19456,t=2,p=1$8TC8kz2KUf0ytBWeFn5CZA$UgL+qvhpeNyijDBfL4A90KjdXOJ7tNP77RrufQhOkgg', 'built-in', true, 'https://minio.bytebytebrew.com/default/Ugly%20Avatar%20Face.png', '111@gmail.com', '18511111111', 'Soybean', 'enabled', '2024-05-15 00:00:00.000', '-1', NULL, NULL),
('2', 'Administrator', '$argon2id$v=19$m=19456,t=2,p=1$8TC8kz2KUf0ytBWeFn5CZA$UgL+qvhpeNyijDBfL4A90KjdXOJ7tNP77RrufQhOkgg', 'built-in', true, 'https://minio.bytebytebrew.com/default/Ugly%20Avatar%20Face.png', '222@gmail.com', '18522222222', 'Admin', 'enabled', '2024-05-15 00:00:00.000', '-1', NULL, NULL),
('3', 'GeneralUser', '$argon2id$v=19$m=19456,t=2,p=1$8TC8kz2KUf0ytBWeFn5CZA$UgL+qvhpeNyijDBfL4A90KjdXOJ7tNP77RrufQhOkgg', 'built-in', true, 'https://minio.bytebytebrew.com/default/Ugly%20Avatar%20Face.png', '333@gmail.com', '18533333333', 'User', 'enabled', '2024-05-15 00:00:00.000', '-1', NULL, NULL)
"#.to_string(),
);
db.execute(insert_stmt).await?;
Ok(())
}
async fn down(&self, _manager: &SchemaManager) -> Result<(), DbErr> {
Ok(())
}
}
| rust | Apache-2.0 | a560191ee087ba509e2060f17937b9f2c8f9be33 | 2026-01-04T20:21:43.261270Z | false |
soybeanjs/soybean-admin-rust | https://github.com/soybeanjs/soybean-admin-rust/blob/a560191ee087ba509e2060f17937b9f2c8f9be33/migration/src/datas/mod.rs | migration/src/datas/mod.rs | pub mod m20241023_102950_insert_sys_domain;
pub mod m20241024_033005_insert_sys_user;
pub mod m20241024_033933_insert_sys_user_role;
pub mod m20241024_034305_insert_sys_role_menu;
pub mod m20241024_034526_insert_sys_role;
pub mod m20241024_034744_insert_sys_menu;
pub mod m20241024_082926_insert_casbin_rule;
| rust | Apache-2.0 | a560191ee087ba509e2060f17937b9f2c8f9be33 | 2026-01-04T20:21:43.261270Z | false |
soybeanjs/soybean-admin-rust | https://github.com/soybeanjs/soybean-admin-rust/blob/a560191ee087ba509e2060f17937b9f2c8f9be33/migration/src/datas/m20241024_034305_insert_sys_role_menu.rs | migration/src/datas/m20241024_034305_insert_sys_role_menu.rs | use sea_orm_migration::{prelude::*, sea_orm::Statement};
#[derive(DeriveMigrationName)]
pub struct Migration;
#[async_trait::async_trait]
impl MigrationTrait for Migration {
async fn up(&self, manager: &SchemaManager) -> Result<(), DbErr> {
let db = manager.get_connection();
let insert_role_menu_stmt = Statement::from_string(
manager.get_database_backend(),
r#"
INSERT INTO sys_role_menu (role_id, menu_id, domain)
VALUES
('1', '50', 'built-in'),
('1', '54', 'built-in'),
('1', '62', 'built-in'),
('1', '63', 'built-in'),
('1', '64', 'built-in'),
('1', '65', 'built-in'),
('3', '50', 'built-in'),
('2', '50', 'built-in'),
('2', '62', 'built-in'),
('1', '51', 'built-in'),
('1', '52', 'built-in'),
('1', '71', 'built-in'),
('1', '72', 'built-in')
"#
.to_string(),
);
db.execute(insert_role_menu_stmt).await?;
Ok(())
}
async fn down(&self, _manager: &SchemaManager) -> Result<(), DbErr> {
Ok(())
}
}
| rust | Apache-2.0 | a560191ee087ba509e2060f17937b9f2c8f9be33 | 2026-01-04T20:21:43.261270Z | false |
soybeanjs/soybean-admin-rust | https://github.com/soybeanjs/soybean-admin-rust/blob/a560191ee087ba509e2060f17937b9f2c8f9be33/migration/src/datas/m20241023_102950_insert_sys_domain.rs | migration/src/datas/m20241023_102950_insert_sys_domain.rs | use sea_orm_migration::{prelude::*, sea_orm::Statement};
#[derive(DeriveMigrationName)]
pub struct Migration;
#[async_trait::async_trait]
impl MigrationTrait for Migration {
async fn up(&self, manager: &SchemaManager) -> Result<(), DbErr> {
let db = manager.get_connection();
let insert_stmt = Statement::from_string(
manager.get_database_backend(),
r#"
INSERT INTO sys_domain (id, code, name, description, status, created_at, created_by, updated_at, updated_by)
VALUES ('1', 'built-in', 'built-in', '内置域,请勿进行任何操作', 'enabled', '2024-05-15 00:00:00.000', '-1', NULL, NULL)
"#.to_string(),
);
db.execute(insert_stmt).await?;
Ok(())
}
async fn down(&self, _manager: &SchemaManager) -> Result<(), DbErr> {
// 当表被删除时，这些数据自然会被删除，所以这里不需要额外的操作
// 如果需要回滚，可以在这里删除插入的默认数据
// let db = manager.get_connection();
// let delete_stmt = Statement::from_string(
// manager.get_database_backend(),
// "DELETE FROM sys_domain WHERE id = '1'".to_string(),
// );
// db.execute(delete_stmt).await?;
Ok(())
}
}
| rust | Apache-2.0 | a560191ee087ba509e2060f17937b9f2c8f9be33 | 2026-01-04T20:21:43.261270Z | false |
soybeanjs/soybean-admin-rust | https://github.com/soybeanjs/soybean-admin-rust/blob/a560191ee087ba509e2060f17937b9f2c8f9be33/migration/src/datas/m20241023_102950_insert_sys_user_role.rs | migration/src/datas/m20241023_102950_insert_sys_user_role.rs | use sea_orm_migration::prelude::*;
use sea_orm_migration::sea_orm::Statement;
#[derive(DeriveMigrationName)]
pub struct Migration;
#[async_trait::async_trait]
impl MigrationTrait for Migration {
async fn up(&self, manager: &SchemaManager) -> Result<(), DbErr> {
let db = manager.get_connection();
// 插入 sys_user_role 数据
let insert_user_role_stmt = Statement::from_string(
manager.get_database_backend(),
r#"
INSERT INTO sys_user_role (user_id, role_id)
VALUES
('1', '1'),
('2', '2'),
('3', '3')
"#.to_string(),
);
db.execute(insert_user_role_stmt).await?;
Ok(())
}
async fn down(&self, _manager: &SchemaManager) -> Result<(), DbErr> {
// 当表被删除时，这些数据自然会被删除，所以这里不需要额外的操作
Ok(())
}
}
| rust | Apache-2.0 | a560191ee087ba509e2060f17937b9f2c8f9be33 | 2026-01-04T20:21:43.261270Z | false |
soybeanjs/soybean-admin-rust | https://github.com/soybeanjs/soybean-admin-rust/blob/a560191ee087ba509e2060f17937b9f2c8f9be33/axum-casbin/src/lib.rs | axum-casbin/src/lib.rs | pub use casbin;
pub use middleware::{CasbinAxumLayer, CasbinAxumMiddleware, CasbinVals};
pub mod middleware;
| rust | Apache-2.0 | a560191ee087ba509e2060f17937b9f2c8f9be33 | 2026-01-04T20:21:43.261270Z | false |
soybeanjs/soybean-admin-rust | https://github.com/soybeanjs/soybean-admin-rust/blob/a560191ee087ba509e2060f17937b9f2c8f9be33/axum-casbin/src/middleware.rs | axum-casbin/src/middleware.rs | use std::{
convert::Infallible,
ops::{Deref, DerefMut},
sync::Arc,
task::{Context, Poll},
};
#[cfg(feature = "runtime-async-std")]
use async_std::sync::RwLock;
use axum::{body, response::Response, BoxError};
use bytes::Bytes;
use casbin::{
prelude::{TryIntoAdapter, TryIntoModel},
CachedEnforcer, CoreApi, Result as CasbinResult,
};
use futures::future::BoxFuture;
use http::{Request, StatusCode};
use http_body::Body as HttpBody;
use http_body_util::Full;
#[cfg(feature = "runtime-tokio")]
use tokio::sync::RwLock;
use tower::{Layer, Service};
#[derive(Clone)]
pub struct CasbinVals {
pub subject: Vec<String>,
pub domain: Option<String>,
}
#[derive(Clone)]
pub struct CasbinAxumLayer {
enforcer: Arc<RwLock<CachedEnforcer>>,
}
impl CasbinAxumLayer {
pub async fn new<M: TryIntoModel, A: TryIntoAdapter>(m: M, a: A) -> CasbinResult<Self> {
let enforcer: CachedEnforcer = CachedEnforcer::new(m, a).await?;
Ok(CasbinAxumLayer {
enforcer: Arc::new(RwLock::new(enforcer)),
})
}
pub fn get_enforcer(&mut self) -> Arc<RwLock<CachedEnforcer>> {
self.enforcer.clone()
}
pub fn set_enforcer(e: Arc<RwLock<CachedEnforcer>>) -> CasbinAxumLayer {
CasbinAxumLayer { enforcer: e }
}
}
impl<S> Layer<S> for CasbinAxumLayer {
type Service = CasbinAxumMiddleware<S>;
fn layer(&self, inner: S) -> Self::Service {
CasbinAxumMiddleware {
enforcer: self.enforcer.clone(),
inner,
}
}
}
impl Deref for CasbinAxumLayer {
type Target = Arc<RwLock<CachedEnforcer>>;
fn deref(&self) -> &Self::Target {
&self.enforcer
}
}
impl DerefMut for CasbinAxumLayer {
fn deref_mut(&mut self) -> &mut Self::Target {
&mut self.enforcer
}
}
#[derive(Clone)]
pub struct CasbinAxumMiddleware<S> {
inner: S,
enforcer: Arc<RwLock<CachedEnforcer>>,
}
impl<S, ReqBody, ResBody> Service<Request<ReqBody>> for CasbinAxumMiddleware<S>
where
S: Service<Request<ReqBody>, Response = Response<ResBody>, Error = Infallible>
+ Clone
+ Send
+ 'static,
S::Future: Send + 'static,
ReqBody: Send + 'static,
Infallible: From<<S as Service<Request<ReqBody>>>::Error>,
ResBody: HttpBody<Data = Bytes> + Send + 'static,
ResBody::Error: Into<BoxError>,
{
type Error = Infallible;
// `BoxFuture` is a type alias for `Pin<Box<dyn Future + Send + 'a>>`
type Future = BoxFuture<'static, Result<Self::Response, Self::Error>>;
type Response = Response;
fn poll_ready(&mut self, cx: &mut Context<'_>) -> Poll<Result<(), Self::Error>> {
self.inner.poll_ready(cx)
}
fn call(&mut self, req: Request<ReqBody>) -> Self::Future {
let cloned_enforcer = self.enforcer.clone();
let not_ready_inner = self.inner.clone();
let mut inner = std::mem::replace(&mut self.inner, not_ready_inner);
Box::pin(async move {
let path = req.uri().path().to_string();
let action = req.method().as_str().to_string();
let option_vals = req.extensions().get::<CasbinVals>().map(|x| x.to_owned());
let vals = match option_vals {
Some(value) => value,
None => {
return Ok(Response::builder()
.status(StatusCode::UNAUTHORIZED)
.body(body::Body::new(Full::from("No authentication token was provided. Please ensure your request includes a valid token.")))
.unwrap());
},
};
let subject = vals.subject.clone();
if !vals.subject.is_empty() {
if let Some(domain) = vals.domain {
let mut lock = cloned_enforcer.write().await;
let mut authorized = false;
let mut enforcement_error = false;
for sub in subject.iter() {
match lock.enforce_mut(vec![
sub.clone(),
domain.clone(),
path.clone(),
action.clone(),
]) {
Ok(true) => {
authorized = true;
break;
},
Ok(false) => continue,
Err(_) => {
enforcement_error = true;
break;
},
}
}
drop(lock);
if enforcement_error {
Ok(Response::builder()
.status(StatusCode::BAD_GATEWAY)
.body(body::Body::new(Full::from("We encountered an unexpected error while processing your request. Our team has been notified, and we are investigating the issue.")))
.unwrap())
} else if authorized {
Ok(inner.call(req).await?.map(body::Body::new))
} else {
Ok(Response::builder()
.status(StatusCode::FORBIDDEN)
.body(body::Body::new(Full::from("You do not have the necessary permissions to access this resource. Please contact support if you believe this is an error.")))
.unwrap())
}
} else {
let mut lock = cloned_enforcer.write().await;
let mut authorized = false;
let mut enforcement_error = false;
for sub in subject.iter() {
match lock.enforce_mut(vec![sub.clone(), path.clone(), action.clone()]) {
Ok(true) => {
authorized = true;
break;
},
Ok(false) => continue,
Err(_) => {
enforcement_error = true;
break;
},
}
}
drop(lock);
if enforcement_error {
Ok(Response::builder()
.status(StatusCode::BAD_GATEWAY)
.body(body::Body::new(Full::from("We encountered an unexpected error while processing your request. Our team has been notified, and we are investigating the issue.")))
.unwrap())
} else if authorized {
Ok(inner.call(req).await?.map(body::Body::new))
} else {
Ok(Response::builder()
.status(StatusCode::FORBIDDEN)
.body(body::Body::new(Full::from("You do not have the necessary permissions to access this resource. Please contact support if you believe this is an error.")))
.unwrap())
}
}
} else {
Ok(Response::builder()
.status(StatusCode::UNAUTHORIZED)
.body(body::Body::new(Full::from(
"No token provided or invalid token type",
)))
.unwrap())
}
})
}
}
| rust | Apache-2.0 | a560191ee087ba509e2060f17937b9f2c8f9be33 | 2026-01-04T20:21:43.261270Z | false |
soybeanjs/soybean-admin-rust | https://github.com/soybeanjs/soybean-admin-rust/blob/a560191ee087ba509e2060f17937b9f2c8f9be33/axum-casbin/tests/test_set_enforcer.rs | axum-casbin/tests/test_set_enforcer.rs | use std::{
convert::Infallible,
sync::Arc,
task::{Context, Poll},
};
#[cfg(feature = "runtime-async-std")]
use async_std::sync::RwLock;
use axum::{response::Response, routing::get, BoxError, Router};
use axum_casbin::{CasbinAxumLayer, CasbinVals};
use axum_test_helpers::TestClient;
use bytes::Bytes;
use casbin::{function_map::key_match2, CachedEnforcer, CoreApi, DefaultModel, FileAdapter};
use futures::future::BoxFuture;
use http::{Request, StatusCode};
use http_body::Body as HttpBody;
#[cfg(feature = "runtime-tokio")]
use tokio::sync::RwLock;
use tower::{Layer, Service};
#[derive(Clone)]
struct FakeAuthLayer;
impl<S> Layer<S> for FakeAuthLayer {
type Service = FakeAuthMiddleware<S>;
fn layer(&self, inner: S) -> Self::Service {
FakeAuthMiddleware { inner }
}
}
#[derive(Clone)]
struct FakeAuthMiddleware<S> {
inner: S,
}
impl<S, ReqBody, ResBody> Service<Request<ReqBody>> for FakeAuthMiddleware<S>
where
S: Service<Request<ReqBody>, Response = Response<ResBody>, Error = Infallible>
+ Clone
+ Send
+ 'static,
S::Future: Send + 'static,
ReqBody: Send + 'static,
Infallible: From<<S as Service<Request<ReqBody>>>::Error>,
ResBody: HttpBody<Data = Bytes> + Send + 'static,
ResBody::Error: Into<BoxError>,
{
type Error = S::Error;
// `BoxFuture` is a type alias for `Pin<Box<dyn Future + Send + 'a>>`
type Future = BoxFuture<'static, Result<Self::Response, Self::Error>>;
type Response = S::Response;
fn poll_ready(&mut self, cx: &mut Context<'_>) -> Poll<Result<(), Self::Error>> {
self.inner.poll_ready(cx)
}
fn call(&mut self, mut req: Request<ReqBody>) -> Self::Future {
let not_ready_inner = self.inner.clone();
let mut inner = std::mem::replace(&mut self.inner, not_ready_inner);
Box::pin(async move {
let vals = CasbinVals {
subject: vec!["alice".to_string()],
domain: None,
};
req.extensions_mut().insert(vals);
inner.call(req).await
})
}
}
// Handler that immediately returns an empty `200 OK` response.
async fn handler() {}
#[cfg_attr(feature = "runtime-tokio", tokio::test)]
#[cfg_attr(feature = "runtime-async-std", async_std::test)]
async fn test_set_enforcer() {
let m = DefaultModel::from_file("examples/rbac_with_pattern_model.conf")
.await
.unwrap();
let a = FileAdapter::new("examples/rbac_with_pattern_policy.csv");
let enforcer = Arc::new(RwLock::new(CachedEnforcer::new(m, a).await.unwrap()));
let casbin_middleware = CasbinAxumLayer::set_enforcer(enforcer);
casbin_middleware
.write()
.await
.get_role_manager()
.write()
.matching_fn(Some(key_match2), None);
let app = Router::new()
.route("/pen/1", get(handler))
.route("/pen/2", get(handler))
.route("/book/:id", get(handler))
.layer(casbin_middleware)
.layer(FakeAuthLayer);
let client = TestClient::new(app);
let resp_pen_1 = client.get("/pen/1").await;
assert_eq!(resp_pen_1.status(), StatusCode::OK);
let resp_book = client.get("/book/2").await;
assert_eq!(resp_book.status(), StatusCode::OK);
let resp_pen_2 = client.get("/pen/2").await;
assert_eq!(resp_pen_2.status(), StatusCode::FORBIDDEN);
}
| rust | Apache-2.0 | a560191ee087ba509e2060f17937b9f2c8f9be33 | 2026-01-04T20:21:43.261270Z | false |
soybeanjs/soybean-admin-rust | https://github.com/soybeanjs/soybean-admin-rust/blob/a560191ee087ba509e2060f17937b9f2c8f9be33/axum-casbin/tests/test_middleware_domain.rs | axum-casbin/tests/test_middleware_domain.rs | use std::{
convert::Infallible,
task::{Context, Poll},
};
use axum::{response::Response, routing::get, BoxError, Router};
use axum_casbin::{CasbinAxumLayer, CasbinVals};
use axum_test_helpers::TestClient;
use bytes::Bytes;
use casbin::{DefaultModel, FileAdapter};
use futures::future::BoxFuture;
use http::{Request, StatusCode};
use http_body::Body as HttpBody;
use tower::{Layer, Service};
#[derive(Clone)]
struct FakeAuthLayer;
impl<S> Layer<S> for FakeAuthLayer {
type Service = FakeAuthMiddleware<S>;
fn layer(&self, inner: S) -> Self::Service {
FakeAuthMiddleware { inner }
}
}
#[derive(Clone)]
struct FakeAuthMiddleware<S> {
inner: S,
}
impl<S, ReqBody, ResBody> Service<Request<ReqBody>> for FakeAuthMiddleware<S>
where
S: Service<Request<ReqBody>, Response = Response<ResBody>, Error = Infallible>
+ Clone
+ Send
+ 'static,
S::Future: Send + 'static,
ReqBody: Send + 'static,
Infallible: From<<S as Service<Request<ReqBody>>>::Error>,
ResBody: HttpBody<Data = Bytes> + Send + 'static,
ResBody::Error: Into<BoxError>,
{
type Error = S::Error;
// `BoxFuture` is a type alias for `Pin<Box<dyn Future + Send + 'a>>`
type Future = BoxFuture<'static, Result<Self::Response, Self::Error>>;
type Response = S::Response;
fn poll_ready(&mut self, cx: &mut Context<'_>) -> Poll<Result<(), Self::Error>> {
self.inner.poll_ready(cx)
}
fn call(&mut self, mut req: Request<ReqBody>) -> Self::Future {
let not_ready_inner = self.inner.clone();
let mut inner = std::mem::replace(&mut self.inner, not_ready_inner);
Box::pin(async move {
let vals = CasbinVals {
subject: vec!["alice".to_string()],
domain: Option::from(String::from("domain1")),
};
req.extensions_mut().insert(vals);
inner.call(req).await
})
}
}
// Handler that immediately returns an empty `200 OK` response.
async fn handler() {}
#[cfg_attr(feature = "runtime-tokio", tokio::test)]
#[cfg_attr(feature = "runtime-async-std", async_std::test)]
async fn test_middleware_domain() {
let m = DefaultModel::from_file("examples/rbac_with_domains_model.conf")
.await
.unwrap();
let a = FileAdapter::new("examples/rbac_with_domains_policy.csv");
let casbin_middleware = CasbinAxumLayer::new(m, a).await.unwrap();
let app = Router::new()
.route("/pen/1", get(handler))
.route("/book/1", get(handler))
.layer(casbin_middleware)
.layer(FakeAuthLayer);
let client = TestClient::new(app);
let resp_pen = client.get("/pen/1").await;
assert_eq!(resp_pen.status(), StatusCode::OK);
let resp_book = client.get("/book/1").await;
assert_eq!(resp_book.status(), StatusCode::FORBIDDEN);
}
| rust | Apache-2.0 | a560191ee087ba509e2060f17937b9f2c8f9be33 | 2026-01-04T20:21:43.261270Z | false |
soybeanjs/soybean-admin-rust | https://github.com/soybeanjs/soybean-admin-rust/blob/a560191ee087ba509e2060f17937b9f2c8f9be33/axum-casbin/tests/test_middleware.rs | axum-casbin/tests/test_middleware.rs | use std::{
convert::Infallible,
task::{Context, Poll},
};
use axum::{response::Response, routing::get, BoxError, Router};
use axum_casbin::{CasbinAxumLayer, CasbinVals};
use axum_test_helpers::TestClient;
use bytes::Bytes;
use casbin::{function_map::key_match2, CoreApi, DefaultModel, FileAdapter};
use futures::future::BoxFuture;
use http::{Request, StatusCode};
use http_body::Body as HttpBody;
use tower::{Layer, Service};
#[derive(Clone)]
struct FakeAuthLayer;
impl<S> Layer<S> for FakeAuthLayer {
type Service = FakeAuthMiddleware<S>;
fn layer(&self, inner: S) -> Self::Service {
FakeAuthMiddleware { inner }
}
}
#[derive(Clone)]
struct FakeAuthMiddleware<S> {
inner: S,
}
impl<S, ReqBody, ResBody> Service<Request<ReqBody>> for FakeAuthMiddleware<S>
where
S: Service<Request<ReqBody>, Response = Response<ResBody>, Error = Infallible>
+ Clone
+ Send
+ 'static,
S::Future: Send + 'static,
ReqBody: Send + 'static,
Infallible: From<<S as Service<Request<ReqBody>>>::Error>,
ResBody: HttpBody<Data = Bytes> + Send + 'static,
ResBody::Error: Into<BoxError>,
{
type Error = S::Error;
// `BoxFuture` is a type alias for `Pin<Box<dyn Future + Send + 'a>>`
type Future = BoxFuture<'static, Result<Self::Response, Self::Error>>;
type Response = S::Response;
fn poll_ready(&mut self, cx: &mut Context<'_>) -> Poll<Result<(), Self::Error>> {
self.inner.poll_ready(cx)
}
fn call(&mut self, mut req: Request<ReqBody>) -> Self::Future {
let not_ready_inner = self.inner.clone();
let mut inner = std::mem::replace(&mut self.inner, not_ready_inner);
Box::pin(async move {
let vals = CasbinVals {
subject: vec!["alice".to_string()],
domain: None,
};
req.extensions_mut().insert(vals);
inner.call(req).await
})
}
}
// Handler that immediately returns an empty `200 OK` response.
async fn handler() {}
#[cfg_attr(feature = "runtime-tokio", tokio::test)]
#[cfg_attr(feature = "runtime-async-std", async_std::test)]
async fn test_middleware() {
let m = DefaultModel::from_file("examples/rbac_with_pattern_model.conf")
.await
.unwrap();
let a = FileAdapter::new("examples/rbac_with_pattern_policy.csv");
let casbin_middleware = CasbinAxumLayer::new(m, a).await.unwrap();
casbin_middleware
.write()
.await
.get_role_manager()
.write()
.matching_fn(Some(key_match2), None);
let app = Router::new()
.route("/pen/1", get(handler))
.route("/pen/2", get(handler))
.route("/book/:id", get(handler))
.layer(casbin_middleware)
.layer(FakeAuthLayer);
let client = TestClient::new(app);
let resp_pen_1 = client.get("/pen/1").await;
assert_eq!(resp_pen_1.status(), StatusCode::OK);
let resp_book = client.get("/book/2").await;
assert_eq!(resp_book.status(), StatusCode::OK);
let resp_pen_2 = client.get("/pen/2").await;
assert_eq!(resp_pen_2.status(), StatusCode::FORBIDDEN);
}
| rust | Apache-2.0 | a560191ee087ba509e2060f17937b9f2c8f9be33 | 2026-01-04T20:21:43.261270Z | false |
soybeanjs/soybean-admin-rust | https://github.com/soybeanjs/soybean-admin-rust/blob/a560191ee087ba509e2060f17937b9f2c8f9be33/server/constant/src/lib.rs | server/constant/src/lib.rs | pub mod definition;
| rust | Apache-2.0 | a560191ee087ba509e2060f17937b9f2c8f9be33 | 2026-01-04T20:21:43.261270Z | false |
soybeanjs/soybean-admin-rust | https://github.com/soybeanjs/soybean-admin-rust/blob/a560191ee087ba509e2060f17937b9f2c8f9be33/server/constant/src/definition/consts.rs | server/constant/src/definition/consts.rs | use strum_macros::{AsRefStr, Display, EnumString};
/// Token 状态枚举
#[derive(Debug, Clone, PartialEq, Eq, AsRefStr, Display, EnumString)]
#[strum(serialize_all = "SCREAMING_SNAKE_CASE")]
pub enum TokenStatus {
/// 活跃状态，可以正常使用
Active,
/// 已被刷新，表示该 token 已被新 token 替换
Refreshed,
/// 已被撤销（手动注销或安全原因）
Revoked,
}
impl TokenStatus {
pub fn is_valid(&self) -> bool {
matches!(self, TokenStatus::Active)
}
pub fn can_refresh(&self) -> bool {
matches!(self, TokenStatus::Active)
}
}
/// 系统事件类型枚举
#[derive(Debug, Clone, PartialEq, Eq, AsRefStr, Display, EnumString)]
#[strum(serialize_all = "snake_case")]
pub enum SystemEvent {
/// 用户认证登录事件
AuthLoggedInEvent,
/// 系统操作日志事件
AuditOperationLoggedEvent,
/// API密钥验证事件
AuthApiKeyValidatedEvent,
}
| rust | Apache-2.0 | a560191ee087ba509e2060f17937b9f2c8f9be33 | 2026-01-04T20:21:43.261270Z | false |
soybeanjs/soybean-admin-rust | https://github.com/soybeanjs/soybean-admin-rust/blob/a560191ee087ba509e2060f17937b9f2c8f9be33/server/constant/src/definition/mod.rs | server/constant/src/definition/mod.rs | pub use audience_const::Audience;
mod audience_const;
pub mod consts;
| rust | Apache-2.0 | a560191ee087ba509e2060f17937b9f2c8f9be33 | 2026-01-04T20:21:43.261270Z | false |
soybeanjs/soybean-admin-rust | https://github.com/soybeanjs/soybean-admin-rust/blob/a560191ee087ba509e2060f17937b9f2c8f9be33/server/constant/src/definition/audience_const.rs | server/constant/src/definition/audience_const.rs | /// Enum to represent different platforms or audiences for JWT authentication.
#[derive(Debug, Clone, Copy, PartialEq, Eq, Hash)]
pub enum Audience {
/// Audience for the official website.
OfficialWebsite,
/// Audience for the admin control panel.
ManagementPlatform,
/// Audience for the mobile application.
MobileApp,
/// Audience for mini-programs or widgets.
MiniProgram,
}
impl Audience {
/// Returns the audience string associated with each platform.
pub fn as_str(self) -> &'static str {
match self {
Audience::OfficialWebsite => "official_website",
Audience::ManagementPlatform => "management_platform",
Audience::MobileApp => "mobile_app",
Audience::MiniProgram => "mini_program",
}
}
}
| rust | Apache-2.0 | a560191ee087ba509e2060f17937b9f2c8f9be33 | 2026-01-04T20:21:43.261270Z | false |
soybeanjs/soybean-admin-rust | https://github.com/soybeanjs/soybean-admin-rust/blob/a560191ee087ba509e2060f17937b9f2c8f9be33/server/service/src/lib.rs | server/service/src/lib.rs | pub mod admin;
mod helper;
pub use server_constant::definition::Audience;
pub use server_global::{project_error, project_info};
pub use server_model::admin::entities::sys_endpoint::Model as SysEndpoint;
| rust | Apache-2.0 | a560191ee087ba509e2060f17937b9f2c8f9be33 | 2026-01-04T20:21:43.261270Z | false |
soybeanjs/soybean-admin-rust | https://github.com/soybeanjs/soybean-admin-rust/blob/a560191ee087ba509e2060f17937b9f2c8f9be33/server/service/src/admin/sys_operation_log_service.rs | server/service/src/admin/sys_operation_log_service.rs | use std::any::Any;
use async_trait::async_trait;
use sea_orm::{
ActiveModelTrait, ColumnTrait, Condition, EntityTrait, PaginatorTrait, QueryFilter, QueryOrder,
Set,
};
use server_core::web::{error::AppError, page::PaginatedData};
use server_global::{global::OperationLogContext, project_error};
use server_model::admin::{
entities::{
prelude::SysOperationLog,
sys_operation_log::{
ActiveModel as SysOperationLogActiveModel, Column as SysOperationLogColumn,
Model as SysOperationLogModel,
},
},
input::OperationLogPageRequest,
};
use tracing::instrument;
use ulid::Ulid;
use crate::helper::db_helper;
#[async_trait]
pub trait TOperationLogService {
async fn find_paginated_operation_logs(
&self,
params: OperationLogPageRequest,
) -> Result<PaginatedData<SysOperationLogModel>, AppError>;
async fn handle_operation_log_event(event: &OperationLogContext) -> Result<(), AppError>;
}
pub struct SysOperationLogService;
#[async_trait]
impl TOperationLogService for SysOperationLogService {
async fn find_paginated_operation_logs(
&self,
params: OperationLogPageRequest,
) -> Result<PaginatedData<SysOperationLogModel>, AppError> {
let db = db_helper::get_db_connection().await?;
let mut query = SysOperationLog::find();
if let Some(ref keywords) = params.keywords {
let condition = Condition::any()
.add(SysOperationLogColumn::Domain.contains(keywords))
.add(SysOperationLogColumn::Username.contains(keywords))
.add(SysOperationLogColumn::Ip.contains(keywords))
.add(SysOperationLogColumn::UserAgent.contains(keywords));
query = query.filter(condition);
}
query = query.order_by_desc(SysOperationLogColumn::CreatedAt);
let total = query
.clone()
.count(db.as_ref())
.await
.map_err(AppError::from)?;
let paginator = query.paginate(db.as_ref(), params.page_details.size);
let records = paginator
.fetch_page(params.page_details.current - 1)
.await
.map_err(AppError::from)?;
Ok(PaginatedData {
current: params.page_details.current,
size: params.page_details.size,
total,
records,
})
}
async fn handle_operation_log_event(event: &OperationLogContext) -> Result<(), AppError> {
let db = db_helper::get_db_connection().await?;
SysOperationLogActiveModel {
id: Set(Ulid::new().to_string()),
user_id: Set(event.user_id.clone().unwrap_or_default()),
username: Set(event.username.clone().unwrap_or_default()),
domain: Set(event.domain.clone().unwrap_or_default()),
module_name: Set(event.module_name.clone()),
description: Set(event.description.clone()),
request_id: Set(event.request_id.clone()),
method: Set(event.method.clone()),
url: Set(event.url.clone()),
ip: Set(event.ip.clone()),
user_agent: Set(event.user_agent.clone()),
params: Set(event.params.clone()),
body: Set(event.body.clone()),
response: Set(event.response.clone()),
start_time: Set(event.start_time),
end_time: Set(event.end_time),
duration: Set(event.duration),
created_at: Set(event.created_at),
}
.insert(db.as_ref())
.await
.map_err(AppError::from)?;
Ok(())
}
}
#[instrument(skip(rx))]
pub async fn sys_operation_log_listener(
mut rx: tokio::sync::mpsc::UnboundedReceiver<Box<dyn Any + Send>>,
) {
while let Some(event) = rx.recv().await {
if let Some(operation_log_context) = event.downcast_ref::<OperationLogContext>() {
if let Err(e) =
SysOperationLogService::handle_operation_log_event(operation_log_context).await
{
project_error!("Failed to handle operation log event: {:?}", e);
}
} else {
project_error!("Received unknown event type in operation log listener");
}
}
}
| rust | Apache-2.0 | a560191ee087ba509e2060f17937b9f2c8f9be33 | 2026-01-04T20:21:43.261270Z | false |
soybeanjs/soybean-admin-rust | https://github.com/soybeanjs/soybean-admin-rust/blob/a560191ee087ba509e2060f17937b9f2c8f9be33/server/service/src/admin/sys_access_key_service.rs | server/service/src/admin/sys_access_key_service.rs | use std::any::Any;
use async_trait::async_trait;
use chrono::Local;
use sea_orm::{
ActiveModelTrait, ColumnTrait, Condition, DatabaseTransaction, EntityTrait, PaginatorTrait,
QueryFilter, Set, TransactionTrait,
};
use server_core::{
sign::{ApiKeyEvent, ValidatorType},
web::{error::AppError, page::PaginatedData},
};
use server_global::project_info;
use server_model::admin::{
entities::{
prelude::SysAccessKey,
sys_access_key::{
ActiveModel as SysAccessKeyActiveModel, Column as SysAccessKeyColumn,
Model as SysAccessKeyModel,
},
},
input::{AccessKeyPageRequest, CreateAccessKeyInput},
};
use tracing::instrument;
use ulid::Ulid;
use crate::helper::db_helper;
use super::sys_access_key_error::AccessKeyError;
#[async_trait]
pub trait TAccessKeyService {
async fn find_paginated_access_keys(
&self,
params: AccessKeyPageRequest,
) -> Result<PaginatedData<SysAccessKeyModel>, AppError>;
async fn create_access_key(
&self,
input: CreateAccessKeyInput,
) -> Result<SysAccessKeyModel, AppError>;
async fn delete_access_key(&self, id: &str) -> Result<(), AppError>;
async fn initialize_access_key(&self) -> Result<(), AppError>;
}
#[derive(Clone)]
pub struct SysAccessKeyService;
impl SysAccessKeyService {
async fn create_access_key_in_transaction(
&self,
txn: &DatabaseTransaction,
access_key: SysAccessKeyActiveModel,
) -> Result<SysAccessKeyModel, AppError> {
let result = access_key.insert(txn).await.map_err(AppError::from)?;
// 添加到验证器
server_core::sign::add_key(ValidatorType::Simple, &result.access_key_id, None).await;
server_core::sign::add_key(
ValidatorType::Complex,
&result.access_key_id,
Some(&result.access_key_secret),
)
.await;
Ok(result)
}
async fn delete_access_key_in_transaction(
&self,
txn: &DatabaseTransaction,
id: &str,
) -> Result<(), AppError> {
// 先获取 access key 信息
let access_key = SysAccessKey::find_by_id(id)
.one(txn)
.await
.map_err(AppError::from)?
.ok_or_else(|| AppError::from(AccessKeyError::AccessKeyNotFound))?;
// 从数据库中删除
SysAccessKey::delete_by_id(id)
.exec(txn)
.await
.map_err(AppError::from)?;
// 从验证器中移除
server_core::sign::remove_key(ValidatorType::Simple, &access_key.access_key_id).await;
server_core::sign::remove_key(ValidatorType::Complex, &access_key.access_key_id).await;
Ok(())
}
}
#[async_trait]
impl TAccessKeyService for SysAccessKeyService {
async fn find_paginated_access_keys(
&self,
params: AccessKeyPageRequest,
) -> Result<PaginatedData<SysAccessKeyModel>, AppError> {
let db = db_helper::get_db_connection().await?;
let mut query = SysAccessKey::find();
if let Some(ref keywords) = params.keywords {
let condition = Condition::any().add(SysAccessKeyColumn::Domain.contains(keywords));
query = query.filter(condition);
}
let total = query
.clone()
.count(db.as_ref())
.await
.map_err(AppError::from)?;
let paginator = query.paginate(db.as_ref(), params.page_details.size);
let records = paginator
.fetch_page(params.page_details.current - 1)
.await
.map_err(AppError::from)?;
Ok(PaginatedData {
current: params.page_details.current,
size: params.page_details.size,
total,
records,
})
}
async fn create_access_key(
&self,
input: CreateAccessKeyInput,
) -> Result<SysAccessKeyModel, AppError> {
let db = db_helper::get_db_connection().await?;
let txn = db.begin().await.map_err(AppError::from)?;
let access_key_id = format!("AK{}", Ulid::new().to_string());
let access_key_secret = format!("SK{}", Ulid::new().to_string());
let access_key = SysAccessKeyActiveModel {
id: Set(Ulid::new().to_string()),
domain: Set(input.domain),
status: Set(input.status),
description: Set(input.description),
access_key_id: Set(access_key_id),
access_key_secret: Set(access_key_secret),
created_at: Set(Local::now().naive_local()),
created_by: Set("TODO".to_string()),
..Default::default()
};
let result = match self
.create_access_key_in_transaction(&txn, access_key)
.await
{
Ok(result) => {
txn.commit().await.map_err(AppError::from)?;
result
},
Err(e) => {
txn.rollback().await.map_err(AppError::from)?;
return Err(e);
},
};
Ok(result)
}
async fn delete_access_key(&self, id: &str) -> Result<(), AppError> {
let db = db_helper::get_db_connection().await?;
let txn = db.begin().await.map_err(AppError::from)?;
match self.delete_access_key_in_transaction(&txn, id).await {
Ok(_) => {
txn.commit().await.map_err(AppError::from)?;
Ok(())
},
Err(e) => {
txn.rollback().await.map_err(AppError::from)?;
Err(e)
},
}
}
async fn initialize_access_key(&self) -> Result<(), AppError> {
let db = db_helper::get_db_connection().await?;
let access_keys = SysAccessKey::find()
.all(db.as_ref())
.await
.map_err(AppError::from)?;
for access_key in access_keys {
server_core::sign::add_key(ValidatorType::Simple, &access_key.access_key_id, None)
.await;
server_core::sign::add_key(
ValidatorType::Complex,
&access_key.access_key_id,
Some(&access_key.access_key_secret),
)
.await;
}
Ok(())
}
}
#[instrument(skip(rx))]
pub async fn api_key_validate_listener(
mut rx: tokio::sync::mpsc::UnboundedReceiver<Box<dyn Any + Send>>,
) {
while let Some(event) = rx.recv().await {
if let Some(api_key_event) = event.downcast_ref::<ApiKeyEvent>() {
project_info!("API key validated: {:?}", api_key_event);
}
}
}
| rust | Apache-2.0 | a560191ee087ba509e2060f17937b9f2c8f9be33 | 2026-01-04T20:21:43.261270Z | false |
soybeanjs/soybean-admin-rust | https://github.com/soybeanjs/soybean-admin-rust/blob/a560191ee087ba509e2060f17937b9f2c8f9be33/server/service/src/admin/sys_organization_service.rs | server/service/src/admin/sys_organization_service.rs | use async_trait::async_trait;
use sea_orm::{ColumnTrait, Condition, EntityTrait, PaginatorTrait, QueryFilter};
use server_core::web::{error::AppError, page::PaginatedData};
use server_model::admin::{
entities::{
prelude::SysOrganization,
sys_organization::{Column as SysOrganizationColumn, Model as SysOrganizationModel},
},
input::OrganizationPageRequest,
};
use crate::helper::db_helper;
#[async_trait]
pub trait TOrganizationService {
async fn find_paginated_organizations(
&self,
params: OrganizationPageRequest,
) -> Result<PaginatedData<SysOrganizationModel>, AppError>;
}
pub struct SysOrganizationService;
#[async_trait]
impl TOrganizationService for SysOrganizationService {
async fn find_paginated_organizations(
&self,
params: OrganizationPageRequest,
) -> Result<PaginatedData<SysOrganizationModel>, AppError> {
let db = db_helper::get_db_connection().await?;
let mut query = SysOrganization::find();
if let Some(ref keywords) = params.keywords {
let condition = Condition::any()
.add(SysOrganizationColumn::Code.contains(keywords))
.add(SysOrganizationColumn::Name.contains(keywords))
.add(SysOrganizationColumn::Description.contains(keywords));
query = query.filter(condition);
}
let total = query
.clone()
.count(db.as_ref())
.await
.map_err(AppError::from)?;
let paginator = query.paginate(db.as_ref(), params.page_details.size);
let records = paginator
.fetch_page(params.page_details.current - 1)
.await
.map_err(AppError::from)?;
Ok(PaginatedData {
current: params.page_details.current,
size: params.page_details.size,
total,
records,
})
}
}
| rust | Apache-2.0 | a560191ee087ba509e2060f17937b9f2c8f9be33 | 2026-01-04T20:21:43.261270Z | false |
soybeanjs/soybean-admin-rust | https://github.com/soybeanjs/soybean-admin-rust/blob/a560191ee087ba509e2060f17937b9f2c8f9be33/server/service/src/admin/sys_endpoint_service.rs | server/service/src/admin/sys_endpoint_service.rs | use std::collections::BTreeMap;
use async_trait::async_trait;
use chrono::Local;
use sea_orm::{
ColumnTrait, Condition, DatabaseConnection, DeleteResult, EntityTrait, IntoActiveModel,
PaginatorTrait, QueryFilter, Set,
};
use server_core::web::{error::AppError, page::PaginatedData};
use server_model::admin::{
entities::{
prelude::SysEndpoint,
sys_endpoint::{
ActiveModel as SysEndpointActiveModel, Column as SysEndpointColumn,
Model as SysEndpointModel,
},
},
input::EndpointPageRequest,
output::EndpointTree,
};
use crate::helper::db_helper;
#[async_trait]
pub trait TEndpointService {
async fn sync_endpoints(&self, endpoints: Vec<SysEndpointModel>) -> Result<(), AppError>;
async fn find_paginated_endpoints(
&self,
params: EndpointPageRequest,
) -> Result<PaginatedData<SysEndpointModel>, AppError>;
async fn tree_endpoint(&self) -> Result<Vec<EndpointTree>, AppError>;
}
pub struct SysEndpointService;
impl SysEndpointService {
async fn batch_update_endpoints(
&self,
db: &DatabaseConnection,
endpoints: Vec<SysEndpointModel>,
) -> Result<(), AppError> {
let now = Local::now().naive_local();
let active_models: Vec<SysEndpointActiveModel> = endpoints
.into_iter()
.map(|endpoint| {
let mut active_model: SysEndpointActiveModel = endpoint.into_active_model();
active_model.updated_at = Set(Some(now));
active_model
})
.collect();
SysEndpoint::insert_many(active_models)
.on_conflict(
sea_orm::sea_query::OnConflict::column(SysEndpointColumn::Id)
.update_columns([
SysEndpointColumn::Path,
SysEndpointColumn::Method,
SysEndpointColumn::Action,
SysEndpointColumn::Resource,
SysEndpointColumn::Controller,
SysEndpointColumn::Summary,
SysEndpointColumn::UpdatedAt,
])
.to_owned(),
)
.exec(db)
.await
.map_err(AppError::from)?;
Ok(())
}
async fn batch_remove_endpoints(
&self,
db: &DatabaseConnection,
endpoints_to_remove: Vec<String>,
) -> Result<DeleteResult, AppError> {
SysEndpoint::delete_many()
.filter(SysEndpointColumn::Id.is_in(endpoints_to_remove))
.exec(db)
.await
.map_err(AppError::from)
}
fn create_endpoint_tree(&self, endpoints: &[SysEndpointModel]) -> Vec<EndpointTree> {
let mut controller_map: BTreeMap<String, EndpointTree> = BTreeMap::new();
for endpoint in endpoints {
let controller = endpoint.controller.clone();
let controller_node =
controller_map
.entry(controller.clone())
.or_insert(EndpointTree {
id: format!("controller-{}", controller),
path: String::new(),
method: String::new(),
action: String::new(),
resource: String::new(),
controller: controller.clone(),
summary: None,
children: Some(Vec::new()),
});
if let Some(children) = &mut controller_node.children {
children.push(EndpointTree {
id: endpoint.id.to_string(),
path: endpoint.path.clone(),
method: endpoint.method.clone(),
action: endpoint.action.clone(),
resource: endpoint.resource.clone(),
controller: endpoint.controller.clone(),
summary: endpoint.summary.clone(),
children: Some(Vec::new()),
});
}
}
controller_map.into_values().collect()
}
}
#[async_trait]
impl TEndpointService for SysEndpointService {
async fn sync_endpoints(&self, new_endpoints: Vec<SysEndpointModel>) -> Result<(), AppError> {
let db = db_helper::get_db_connection().await?;
// 获取数据库中现有的所有端点
let existing_endpoints = SysEndpoint::find()
.all(db.as_ref())
.await
.map_err(AppError::from)?;
// 批量更新和插入新的端点
self.batch_update_endpoints(db.as_ref(), new_endpoints.clone())
.await?;
// 只有在数据库中已经存在端点的情况下才执行删除操作
if !existing_endpoints.is_empty() {
// 找出需要删除的端点
let endpoints_to_remove: Vec<String> = existing_endpoints
.iter()
.filter(|existing_endpoint| {
!new_endpoints.iter().any(|e| {
e.path == existing_endpoint.path && e.method == existing_endpoint.method
})
})
.map(|endpoint| endpoint.id.clone())
.collect();
// 批量删除不再存在的端点
if !endpoints_to_remove.is_empty() {
self.batch_remove_endpoints(db.as_ref(), endpoints_to_remove)
.await?;
}
}
Ok(())
}
async fn find_paginated_endpoints(
&self,
params: EndpointPageRequest,
) -> Result<PaginatedData<SysEndpointModel>, AppError> {
let db = db_helper::get_db_connection().await?;
let mut query = SysEndpoint::find();
if let Some(ref keywords) = params.keywords {
let condition = Condition::any()
.add(SysEndpointColumn::Path.contains(keywords))
.add(SysEndpointColumn::Method.contains(keywords))
.add(SysEndpointColumn::Controller.contains(keywords));
query = query.filter(condition);
}
let total = query
.clone()
.count(db.as_ref())
.await
.map_err(AppError::from)?;
let paginator = query.paginate(db.as_ref(), params.page_details.size);
let records = paginator
.fetch_page(params.page_details.current - 1)
.await
.map_err(AppError::from)?;
Ok(PaginatedData {
current: params.page_details.current,
size: params.page_details.size,
total,
records,
})
}
async fn tree_endpoint(&self) -> Result<Vec<EndpointTree>, AppError> {
let db = db_helper::get_db_connection().await?;
let endpoints = SysEndpoint::find()
.all(db.as_ref())
.await
.map_err(AppError::from)?;
Ok(self.create_endpoint_tree(&endpoints))
}
}
| rust | Apache-2.0 | a560191ee087ba509e2060f17937b9f2c8f9be33 | 2026-01-04T20:21:43.261270Z | false |
soybeanjs/soybean-admin-rust | https://github.com/soybeanjs/soybean-admin-rust/blob/a560191ee087ba509e2060f17937b9f2c8f9be33/server/service/src/admin/sys_domain_service.rs | server/service/src/admin/sys_domain_service.rs | use async_trait::async_trait;
use chrono::Local;
use sea_orm::{
ActiveModelTrait, ColumnTrait, Condition, EntityTrait, PaginatorTrait, QueryFilter, Set,
};
use server_core::web::{error::AppError, page::PaginatedData};
use server_model::admin::{
entities::{
prelude::SysDomain,
sea_orm_active_enums::Status,
sys_domain::{
ActiveModel as SysDomainActiveModel, Column as SysDomainColumn, Model as SysDomainModel,
},
},
input::{CreateDomainInput, DomainPageRequest, UpdateDomainInput},
};
use ulid::Ulid;
use crate::{admin::sys_domain_error::DomainError, helper::db_helper};
#[async_trait]
pub trait TDomainService {
async fn find_paginated_domains(
&self,
params: DomainPageRequest,
) -> Result<PaginatedData<SysDomainModel>, AppError>;
async fn create_domain(&self, input: CreateDomainInput) -> Result<SysDomainModel, AppError>;
async fn get_domain(&self, id: &str) -> Result<SysDomainModel, AppError>;
async fn update_domain(&self, input: UpdateDomainInput) -> Result<SysDomainModel, AppError>;
async fn delete_domain(&self, id: &str) -> Result<(), AppError>;
}
#[derive(Clone)]
pub struct SysDomainService;
impl SysDomainService {
async fn check_domain_exists(
&self,
id: Option<&str>,
code: &str,
name: &str,
) -> Result<(), AppError> {
let id_str = id.unwrap_or("-1");
let db = db_helper::get_db_connection().await?;
let code_exists = SysDomain::find()
.filter(SysDomainColumn::Code.eq(code))
.filter(SysDomainColumn::Id.ne(id_str))
.one(db.as_ref())
.await
.map_err(AppError::from)?
.is_some();
if code_exists {
return Err(DomainError::DuplicateCode.into());
}
let name_exists = SysDomain::find()
.filter(SysDomainColumn::Name.eq(name))
.filter(SysDomainColumn::Id.ne(id_str))
.one(db.as_ref())
.await
.map_err(AppError::from)?
.is_some();
if name_exists {
return Err(DomainError::DuplicateName.into());
}
Ok(())
}
}
#[async_trait]
impl TDomainService for SysDomainService {
async fn find_paginated_domains(
&self,
params: DomainPageRequest,
) -> Result<PaginatedData<SysDomainModel>, AppError> {
let db = db_helper::get_db_connection().await?;
let mut query = SysDomain::find();
if let Some(ref keywords) = params.keywords {
let condition = Condition::any().add(SysDomainColumn::Name.contains(keywords));
query = query.filter(condition);
}
let total = query
.clone()
.count(db.as_ref())
.await
.map_err(AppError::from)?;
let paginator = query.paginate(db.as_ref(), params.page_details.size);
let records = paginator
.fetch_page(params.page_details.current - 1)
.await
.map_err(AppError::from)?;
Ok(PaginatedData {
current: params.page_details.current,
size: params.page_details.size,
total,
records,
})
}
async fn create_domain(&self, input: CreateDomainInput) -> Result<SysDomainModel, AppError> {
self.check_domain_exists(None, &input.code, &input.name)
.await?;
let db = db_helper::get_db_connection().await?;
let domain = SysDomainActiveModel {
id: Set(Ulid::new().to_string()),
code: Set(input.code),
name: Set(input.name),
description: Set(input.description),
status: Set(Status::Enabled),
created_at: Set(Local::now().naive_local()),
created_by: Set("TODO".to_string()),
..Default::default()
};
let result = domain.insert(db.as_ref()).await.map_err(AppError::from)?;
Ok(result)
}
async fn get_domain(&self, id: &str) -> Result<SysDomainModel, AppError> {
let db = db_helper::get_db_connection().await?;
SysDomain::find_by_id(id)
.one(db.as_ref())
.await
.map_err(AppError::from)?
.ok_or_else(|| DomainError::DomainNotFound.into())
}
async fn update_domain(&self, input: UpdateDomainInput) -> Result<SysDomainModel, AppError> {
let db = db_helper::get_db_connection().await?;
let existing_domain = self.get_domain(&input.id).await?;
if existing_domain.code == "built-in" {
return Err(DomainError::BuiltInDomain.into());
}
self.check_domain_exists(Some(&input.id), &input.domain.code, &input.domain.name)
.await?;
let mut domain: SysDomainActiveModel = existing_domain.into();
domain.code = Set(input.domain.code);
domain.name = Set(input.domain.name);
domain.description = Set(input.domain.description);
let updated_domain = domain.update(db.as_ref()).await.map_err(AppError::from)?;
Ok(updated_domain)
}
async fn delete_domain(&self, id: &str) -> Result<(), AppError> {
let domain = self.get_domain(id).await?;
if domain.code == "built-in" {
return Err(DomainError::BuiltInDomain.into());
}
let db = db_helper::get_db_connection().await?;
SysDomain::delete_by_id(id)
.exec(db.as_ref())
.await
.map_err(AppError::from)?;
Ok(())
}
}
| rust | Apache-2.0 | a560191ee087ba509e2060f17937b9f2c8f9be33 | 2026-01-04T20:21:43.261270Z | false |
soybeanjs/soybean-admin-rust | https://github.com/soybeanjs/soybean-admin-rust/blob/a560191ee087ba509e2060f17937b9f2c8f9be33/server/service/src/admin/sys_role_service.rs | server/service/src/admin/sys_role_service.rs | use async_trait::async_trait;
use chrono::Local;
use sea_orm::{
ActiveModelTrait, ColumnTrait, Condition, EntityTrait, PaginatorTrait, QueryFilter, Set,
};
use server_core::web::{error::AppError, page::PaginatedData};
use server_model::admin::{
entities::{
prelude::SysRole,
sys_role::{
ActiveModel as SysRoleActiveModel, Column as SysRoleColumn, Model as SysRoleModel,
},
},
input::{CreateRoleInput, RolePageRequest, UpdateRoleInput},
};
use super::sys_role_error::RoleError;
use crate::helper::db_helper;
use ulid::Ulid;
#[async_trait]
pub trait TRoleService {
async fn find_paginated_roles(
&self,
params: RolePageRequest,
) -> Result<PaginatedData<SysRoleModel>, AppError>;
async fn create_role(&self, input: CreateRoleInput) -> Result<SysRoleModel, AppError>;
async fn get_role(&self, id: &str) -> Result<SysRoleModel, AppError>;
async fn update_role(&self, input: UpdateRoleInput) -> Result<SysRoleModel, AppError>;
async fn delete_role(&self, id: &str) -> Result<(), AppError>;
}
#[derive(Clone)]
pub struct SysRoleService;
impl SysRoleService {
async fn check_role_exists(&self, id: Option<&str>, code: &str) -> Result<(), AppError> {
let db = db_helper::get_db_connection().await?;
let mut query = SysRole::find().filter(SysRoleColumn::Code.eq(code));
if let Some(id) = id {
query = query.filter(SysRoleColumn::Id.ne(id));
}
let existing_role = query.one(db.as_ref()).await.map_err(AppError::from)?;
if existing_role.is_some() {
return Err(RoleError::DuplicateRoleCode.into());
}
Ok(())
}
}
#[async_trait]
impl TRoleService for SysRoleService {
async fn find_paginated_roles(
&self,
params: RolePageRequest,
) -> Result<PaginatedData<SysRoleModel>, AppError> {
let db = db_helper::get_db_connection().await?;
let mut query = SysRole::find();
if let Some(ref keywords) = params.keywords {
let condition = Condition::any().add(SysRoleColumn::Name.contains(keywords));
query = query.filter(condition);
}
let total = query
.clone()
.count(db.as_ref())
.await
.map_err(AppError::from)?;
let paginator = query.paginate(db.as_ref(), params.page_details.size);
let records = paginator
.fetch_page(params.page_details.current - 1)
.await
.map_err(AppError::from)?;
Ok(PaginatedData {
current: params.page_details.current,
size: params.page_details.size,
total,
records,
})
}
async fn create_role(&self, input: CreateRoleInput) -> Result<SysRoleModel, AppError> {
let db = db_helper::get_db_connection().await?;
self.check_role_exists(None, &input.code).await?;
let role = SysRoleActiveModel {
id: Set(Ulid::new().to_string()),
pid: Set(input.pid),
code: Set(input.code),
name: Set(input.name),
status: Set(input.status),
description: Set(input.description),
created_at: Set(Local::now().naive_local()),
created_by: Set("TODO".to_string()),
..Default::default()
};
let result = role.insert(db.as_ref()).await.map_err(AppError::from)?;
Ok(result)
}
async fn get_role(&self, id: &str) -> Result<SysRoleModel, AppError> {
let db = db_helper::get_db_connection().await?;
SysRole::find_by_id(id)
.one(db.as_ref())
.await
.map_err(AppError::from)?
.ok_or_else(|| RoleError::RoleNotFound.into())
}
async fn update_role(&self, input: UpdateRoleInput) -> Result<SysRoleModel, AppError> {
let db = db_helper::get_db_connection().await?;
self.check_role_exists(Some(&input.id), &input.role.code)
.await?;
let role: SysRoleActiveModel = SysRole::find_by_id(&input.id)
.one(db.as_ref())
.await
.map_err(AppError::from)?
.ok_or_else(|| AppError::from(RoleError::RoleNotFound))?
.into();
let role = SysRoleActiveModel {
id: Set(input.id.clone()),
pid: Set(input.role.pid),
code: Set(input.role.code),
name: Set(input.role.name),
description: Set(input.role.description),
updated_at: Set(Some(Local::now().naive_local())),
..role
};
let updated_role = role.update(db.as_ref()).await.map_err(AppError::from)?;
Ok(updated_role)
}
async fn delete_role(&self, id: &str) -> Result<(), AppError> {
let db = db_helper::get_db_connection().await?;
SysRole::delete_by_id(id)
.exec(db.as_ref())
.await
.map_err(AppError::from)?;
Ok(())
}
}
| rust | Apache-2.0 | a560191ee087ba509e2060f17937b9f2c8f9be33 | 2026-01-04T20:21:43.261270Z | false |
soybeanjs/soybean-admin-rust | https://github.com/soybeanjs/soybean-admin-rust/blob/a560191ee087ba509e2060f17937b9f2c8f9be33/server/service/src/admin/mod.rs | server/service/src/admin/mod.rs | pub use errors::*;
pub use server_model::admin::{
entities::{
prelude::{SysDomain, SysEndpoint, SysMenu, SysRole, SysUser},
sys_access_key::Model as SysAccessKeyModel,
sys_domain::Model as SysDomainModel,
sys_endpoint::Model as SysEndpointModel,
sys_login_log::Model as SysLoginLogModel,
sys_menu::Model as SysMenuModel,
sys_operation_log::Model as SysOperationLogModel,
sys_organization::Model as SysOrganizationModel,
sys_role::Model as SysRoleModel,
},
input::*,
output::*,
};
pub use sys_access_key_service::{
api_key_validate_listener, SysAccessKeyService, TAccessKeyService,
};
pub use sys_auth_service::{
auth_login_listener, jwt_created_listener, SysAuthService, TAuthService,
};
pub use sys_authorization_service::{SysAuthorizationService, TAuthorizationService};
pub use sys_domain_service::{SysDomainService, TDomainService};
pub use sys_endpoint_service::{SysEndpointService, TEndpointService};
pub use sys_login_log_service::{SysLoginLogService, TLoginLogService};
pub use sys_menu_service::{SysMenuService, TMenuService};
pub use sys_operation_log_service::{
sys_operation_log_listener, SysOperationLogService, TOperationLogService,
};
pub use sys_organization_service::{SysOrganizationService, TOrganizationService};
pub use sys_role_service::{SysRoleService, TRoleService};
pub use sys_user_service::{SysUserService, TUserService};
pub mod dto;
pub mod errors;
mod sys_access_key_service;
mod sys_auth_service;
mod sys_authorization_service;
mod sys_domain_service;
mod sys_endpoint_service;
mod sys_login_log_service;
mod sys_menu_service;
mod sys_operation_log_service;
mod sys_organization_service;
mod sys_role_service;
mod sys_user_service;
mod event_handlers;
mod events;
| rust | Apache-2.0 | a560191ee087ba509e2060f17937b9f2c8f9be33 | 2026-01-04T20:21:43.261270Z | false |
soybeanjs/soybean-admin-rust | https://github.com/soybeanjs/soybean-admin-rust/blob/a560191ee087ba509e2060f17937b9f2c8f9be33/server/service/src/admin/sys_auth_service.rs | server/service/src/admin/sys_auth_service.rs | use std::any::Any;
use async_trait::async_trait;
use sea_orm::{
ColumnTrait, DatabaseConnection, EntityTrait, JoinType, QueryFilter, QueryOrder, QuerySelect,
RelationTrait,
};
use server_constant::definition::{consts::SystemEvent, Audience};
use server_core::web::{
auth::Claims,
error::AppError,
jwt::{JwtError, JwtUtils},
};
use server_global::global;
use server_model::admin::{
entities::{
prelude::{SysRole, SysUser},
sea_orm_active_enums::Status,
sys_domain::Column as SysDomainColumn,
sys_menu::{Column as SysMenuColumn, Entity as SysMenuEntity, Model as SysMenuModel},
sys_role::{Column as SysRoleColumn, Entity as SysRoleEntity, Relation as SysRoleRelation},
sys_role_menu::{Column as SysRoleMenuColumn, Entity as SysRoleMenuEntity},
sys_user::{Column as SysUserColumn, Relation as SysUserRelation},
sys_user_role::Relation as SysUserRoleRelation,
},
input::LoginInput,
output::{AuthOutput, MenuRoute, RouteMeta, UserRoute, UserWithDomainAndOrgOutput},
};
use server_utils::{SecureUtil, TreeBuilder};
use thiserror::Error;
use tokio::sync::mpsc;
use tracing::{error, instrument};
use ulid::Ulid;
use super::{
dto::sys_auth_dto::LoginContext, event_handlers::auth_event_handler::AuthEventHandler,
};
use crate::{
admin::{event_handlers::auth_event_handler::AuthEvent, sys_user_error::UserError},
helper::db_helper,
project_error, project_info,
};
macro_rules! select_user_with_domain_and_org_info {
($query:expr) => {{
$query
.select_only()
.column_as(SysUserColumn::Id, "id")
.column_as(SysUserColumn::Domain, "domain")
.column_as(SysUserColumn::Username, "username")
.column_as(SysUserColumn::Password, "password")
.column_as(SysUserColumn::NickName, "nick_name")
.column_as(SysUserColumn::Avatar, "avatar")
.column_as(SysDomainColumn::Code, "domain_code")
.column_as(SysDomainColumn::Name, "domain_name")
}};
}
#[derive(Error, Debug)]
pub enum EventError {
#[error("Failed to send event: {0}")]
SendError(#[from] tokio::sync::mpsc::error::SendError<Box<dyn std::any::Any + Send>>),
#[error("Failed to handle login event: {0}")]
LoginHandlerError(String),
}
#[async_trait]
pub trait TAuthService: Send + Sync {
async fn pwd_login(
&self,
input: LoginInput,
context: LoginContext,
) -> Result<AuthOutput, AppError>;
async fn get_user_routes(
&self,
role_codes: &[String],
domain: &str,
) -> Result<UserRoute, AppError>;
}
#[derive(Clone)]
pub struct SysAuthService;
impl SysAuthService {
/// 查找第一个有效的路由路径
#[allow(dead_code)]
fn find_first_valid_route(routes: &[MenuRoute]) -> Option<String> {
for route in routes {
if !route.path.is_empty() && route.path != "/" {
return Some(route.path.clone());
}
if let Some(children) = &route.children {
if let Some(path) = Self::find_first_valid_route(children) {
return Some(path);
}
}
}
None
}
}
#[async_trait]
impl TAuthService for SysAuthService {
#[instrument(skip(self, input), fields(username = %input.identifier, domain = %context.domain))]
async fn pwd_login(
&self,
input: LoginInput,
context: LoginContext,
) -> Result<AuthOutput, AppError> {
// 验证用户并获取角色
let (user, role_codes) = self
.verify_user(&input.identifier, &input.password, &context.domain)
.await?;
// 生成认证输出
let auth_output = generate_auth_output(
user.id.clone(),
user.username.clone(),
role_codes,
user.domain_code.clone(),
None,
context.audience,
)
.await?;
// 发送认证事件
self.send_login_event(&user, &auth_output, &context).await;
Ok(auth_output)
}
#[instrument(skip(self), fields(roles = ?role_codes, domain = %domain))]
async fn get_user_routes(
&self,
role_codes: &[String],
domain: &str,
) -> Result<UserRoute, AppError> {
if role_codes.is_empty() {
return Ok(UserRoute {
routes: vec![],
home: "/home".to_string(),
});
}
let db = db_helper::get_db_connection().await?;
let menu_ids = SysRoleMenuEntity::find()
.select_only()
.column(SysRoleMenuColumn::MenuId)
.join_rev(
JoinType::InnerJoin,
SysRoleEntity::has_many(SysRoleMenuEntity).into(),
)
.filter(SysRoleColumn::Code.is_in(role_codes.to_vec()))
.filter(SysRoleMenuColumn::Domain.eq(domain))
.distinct()
.into_tuple::<i32>()
.all(db.as_ref())
.await?;
let menus = SysMenuEntity::find()
.filter(SysMenuColumn::Id.is_in(menu_ids))
.filter(SysMenuColumn::Status.eq(Status::Enabled))
.order_by_asc(SysMenuColumn::Sequence)
.into_model::<SysMenuModel>()
.all(db.as_ref())
.await?;
let menu_routes: Vec<MenuRoute> = menus
.into_iter()
.map(|menu| MenuRoute {
name: menu.route_name,
path: menu.route_path,
component: menu.component,
meta: RouteMeta {
title: menu.menu_name,
i18n_key: menu.i18n_key,
keep_alive: menu.keep_alive,
constant: menu.constant,
icon: menu.icon,
order: menu.sequence,
href: menu.href,
hide_in_menu: menu.hide_in_menu,
active_menu: menu.active_menu,
multi_tab: menu.multi_tab,
},
children: Some(vec![]),
id: menu.id,
pid: menu.pid,
})
.collect();
let menu_routes_ref = menu_routes.clone();
let routes = TreeBuilder::build(
menu_routes,
|route| route.name.clone(),
|route| {
if route.pid == "0" {
None
} else {
menu_routes_ref
.iter()
.find(|m| m.id.to_string() == route.pid)
.map(|m| m.name.clone())
}
},
|route| route.meta.order,
|route, children| {
route.children = Some(children);
},
);
// let home = Self::find_first_valid_route(&routes).unwrap_or_else(|| "/home".to_string());
let home = "home".to_string();
Ok(UserRoute { routes, home })
}
}
impl SysAuthService {
/// 验证用户身份
async fn verify_user(
&self,
identifier: &str,
password: &str,
domain: &str,
) -> Result<(UserWithDomainAndOrgOutput, Vec<String>), AppError> {
let db = db_helper::get_db_connection().await?;
let user = select_user_with_domain_and_org_info!(SysUser::find())
.filter(SysUserColumn::Username.eq(identifier))
.filter(SysDomainColumn::Code.eq(domain))
.join(JoinType::InnerJoin, SysUserRelation::SysDomain.def())
.into_model::<UserWithDomainAndOrgOutput>()
.one(db.as_ref())
.await
.map_err(AppError::from)?
.ok_or_else(|| AppError::from(UserError::UserNotFound))?;
//TODO validate user status and domain status
// 验证密码
if !SecureUtil::verify_password(password.as_bytes(), &user.password)
.map_err(|_| AppError::from(UserError::AuthenticationFailed))?
{
return Err(AppError::from(UserError::WrongPassword));
}
// 获取角色
let role_codes = self.get_user_roles(&user.id, &db).await?;
Ok((user, role_codes))
}
/// 获取用户角色
async fn get_user_roles(
&self,
user_id: &str,
db: &DatabaseConnection,
) -> Result<Vec<String>, AppError> {
SysRole::find()
.join(JoinType::InnerJoin, SysRoleRelation::SysUserRole.def())
.join(JoinType::InnerJoin, SysUserRoleRelation::SysUser.def())
.filter(SysUserColumn::Id.eq(user_id))
.all(db)
.await
.map(|roles| roles.iter().map(|role| role.code.clone()).collect())
.map_err(AppError::from)
}
async fn send_login_event(
&self,
user: &UserWithDomainAndOrgOutput,
auth_output: &AuthOutput,
context: &LoginContext,
) {
let auth_event = AuthEvent {
user_id: user.id.clone(),
username: user.username.clone(),
domain: user.domain_code.clone(),
access_token: auth_output.token.clone(),
refresh_token: auth_output.refresh_token.clone(),
client_ip: context.client_ip.clone(),
client_port: context.client_port,
address: context.address.clone(),
user_agent: context.user_agent.clone(),
request_id: context.request_id.clone(),
login_type: context.login_type.clone(),
};
global::send_dyn_event(
SystemEvent::AuthLoggedInEvent.as_ref(),
Box::new(auth_event),
);
}
async fn check_login_security(
&self,
_username: &str,
_client_ip: &str,
) -> Result<(), AppError> {
// TODO: 实现登录安全检查
// 1. 检查登录失败次数
// 2. 检查 IP 黑名单
// 3. 检查账号是否被锁定
// 4. 检查是否在允许的时间范围内
Ok(())
}
#[allow(dead_code)]
async fn pwd_login_with_security(
&self,
input: LoginInput,
context: LoginContext,
) -> Result<AuthOutput, AppError> {
self.check_login_security(&input.identifier, &context.client_ip)
.await?;
self.pwd_login(input, context).await
}
}
#[allow(dead_code)]
#[instrument(skip(sender, auth_event))]
async fn send_auth_event(
sender: mpsc::UnboundedSender<Box<dyn std::any::Any + Send>>,
auth_event: AuthEvent,
) -> Result<(), EventError> {
sender
.send(Box::new(auth_event))
.map_err(EventError::from)?;
Ok(())
}
pub async fn generate_auth_output(
user_id: String,
username: String,
role_codes: Vec<String>,
domain_code: String,
organization_name: Option<String>,
audience: Audience,
) -> Result<AuthOutput, JwtError> {
let claims = Claims::new(
user_id,
audience.as_str().to_string(),
username,
role_codes,
domain_code,
organization_name,
);
let token = JwtUtils::generate_token(&claims).await?;
Ok(AuthOutput {
token,
refresh_token: Ulid::new().to_string(),
})
}
#[instrument(skip(rx))]
pub async fn auth_login_listener(
mut rx: tokio::sync::mpsc::UnboundedReceiver<Box<dyn Any + Send>>,
) {
while let Some(event) = rx.recv().await {
if let Some(auth_event) = event.downcast_ref::<AuthEvent>() {
if let Err(e) = handle_auth_event(auth_event).await {
project_error!("Failed to handle AuthEvent: {:?}", e);
}
}
}
}
#[instrument(skip(auth_event), fields(user_id = %auth_event.user_id, username = %auth_event.username))]
async fn handle_auth_event(auth_event: &AuthEvent) -> Result<(), EventError> {
AuthEventHandler::handle_login(AuthEvent {
user_id: auth_event.user_id.clone(),
username: auth_event.username.clone(),
domain: auth_event.domain.clone(),
access_token: auth_event.access_token.clone(),
refresh_token: auth_event.refresh_token.clone(),
client_ip: auth_event.client_ip.clone(),
address: auth_event.address.clone(),
client_port: auth_event.client_port,
user_agent: auth_event.user_agent.clone(),
request_id: auth_event.request_id.clone(),
login_type: auth_event.login_type.clone(),
})
.await
.map_err(|e| EventError::LoginHandlerError(format!("{:?}", e)))
}
#[instrument(skip(rx))]
pub async fn jwt_created_listener(mut rx: tokio::sync::mpsc::UnboundedReceiver<String>) {
while let Some(jwt) = rx.recv().await {
project_info!("JWT created: {}", jwt);
// TODO: Consider storing the token into the database
}
}
| rust | Apache-2.0 | a560191ee087ba509e2060f17937b9f2c8f9be33 | 2026-01-04T20:21:43.261270Z | false |
soybeanjs/soybean-admin-rust | https://github.com/soybeanjs/soybean-admin-rust/blob/a560191ee087ba509e2060f17937b9f2c8f9be33/server/service/src/admin/sys_authorization_service.rs | server/service/src/admin/sys_authorization_service.rs | use std::sync::Arc;
use async_trait::async_trait;
use axum_casbin::casbin::{CoreApi, MgmtApi, RbacApi};
use sea_orm::{ColumnTrait, EntityTrait, QueryFilter, TransactionTrait};
use server_core::web::error::AppError;
use server_model::admin::entities::{
prelude::{SysDomain, SysEndpoint, SysMenu, SysRole, SysRoleMenu, SysUser, SysUserRole},
sys_domain::Column as SysDomainColumn,
sys_endpoint::Column as SysEndpointColumn,
sys_menu::Column as SysMenuColumn,
sys_role::Column as SysRoleColumn,
sys_role_menu::{ActiveModel as SysRoleMenuActiveModel, Column as SysRoleMenuColumn},
sys_user_role::{ActiveModel as SysUserRoleActiveModel, Column as SysUserRoleColumn},
};
use thiserror::Error;
use tokio::sync::RwLock;
use crate::helper::db_helper;
#[derive(Error, Debug)]
pub enum AuthorizationError {
#[error("Domain not found")]
DomainNotFound,
#[error("Role not found")]
RoleNotFound,
#[error("One or more permissions not found")]
PermissionsNotFound,
#[error("One or more routes not found")]
RoutesNotFound,
#[error("One or more users not found")]
UsersNotFound,
}
impl From<AuthorizationError> for AppError {
fn from(error: AuthorizationError) -> Self {
AppError {
code: 400,
message: error.to_string(),
}
}
}
#[async_trait]
pub trait TAuthorizationService: Send + Sync {
/// 为角色分配权限
async fn assign_permission(
&self,
domain: String,
role_id: String,
permissions: Vec<String>,
enforcer: Arc<RwLock<impl CoreApi + MgmtApi + RbacApi + Send + Sync>>,
) -> Result<(), AppError>;
/// 为角色分配路由
async fn assign_routes(
&self,
domain: String,
role_id: String,
route_ids: Vec<i32>,
) -> Result<(), AppError>;
/// 为角色分配用户
async fn assign_users(&self, role_id: String, user_ids: Vec<String>) -> Result<(), AppError>;
}
#[derive(Clone)]
pub struct SysAuthorizationService;
impl SysAuthorizationService {
async fn check_domain_and_role(
&self,
domain_code: &str,
role_id: &str,
) -> Result<(String, String, String), AppError> {
let db = db_helper::get_db_connection().await?;
let domain = SysDomain::find()
.filter(SysDomainColumn::Code.eq(domain_code))
.one(db.as_ref())
.await
.map_err(AppError::from)?;
let domain = domain.ok_or_else(|| AuthorizationError::DomainNotFound)?;
let role = SysRole::find()
.filter(SysRoleColumn::Id.eq(role_id))
.one(db.as_ref())
.await
.map_err(AppError::from)?;
let role = role.ok_or_else(|| AuthorizationError::RoleNotFound)?;
Ok((domain.code, role_id.to_string(), role.code))
}
async fn check_role(&self, role_id: &str) -> Result<String, AppError> {
let db = db_helper::get_db_connection().await?;
let role = SysRole::find()
.filter(SysRoleColumn::Id.eq(role_id))
.one(db.as_ref())
.await
.map_err(AppError::from)?;
let role = role.ok_or_else(|| AuthorizationError::RoleNotFound)?;
Ok(role.code)
}
/// 同步角色权限
async fn sync_role_permissions(
&self,
role_code: &str,
domain: &str,
new_permissions: Vec<server_model::admin::entities::sys_endpoint::Model>,
enforcer: Arc<RwLock<impl CoreApi + MgmtApi + RbacApi + Send + Sync>>,
) -> Result<(), AppError> {
let mut enforcer_write = enforcer.write().await;
let existing_permissions =
enforcer_write.get_filtered_policy(0, vec![role_code.to_string(), domain.to_string()]);
println!("existing_permissions: {:?}", existing_permissions);
let new_policies: Vec<Vec<String>> = new_permissions
.iter()
.map(|perm| {
vec![
role_code.to_string(),
domain.to_string(),
perm.path.clone(),
perm.method.clone(),
]
})
.collect();
println!("new_policies: {:?}", new_policies);
let existing_policies: Vec<Vec<String>> = existing_permissions
.iter()
.map(|perm| {
vec![
perm[0].clone(),
perm[1].clone(),
perm[2].clone(),
perm[3].clone(),
]
})
.collect();
println!("existing_policies: {:?}", existing_policies);
let policies_to_remove: Vec<Vec<String>> = existing_policies
.iter()
.filter(|policy| !new_policies.contains(policy))
.cloned()
.collect();
let policies_to_add: Vec<Vec<String>> = new_policies
.iter()
.filter(|policy| !existing_policies.contains(policy))
.cloned()
.collect();
if !policies_to_remove.is_empty() {
let _ = enforcer_write
.remove_policies(policies_to_remove)
.await
.map_err(|e| AppError {
code: 500,
message: e.to_string(),
})?;
}
if !policies_to_add.is_empty() {
let _ = enforcer_write
.add_policies(policies_to_add)
.await
.map_err(|e| AppError {
code: 500,
message: e.to_string(),
})?;
}
Ok(())
}
}
#[async_trait]
impl TAuthorizationService for SysAuthorizationService {
async fn assign_permission(
&self,
domain: String,
role_id: String,
permissions: Vec<String>,
enforcer: Arc<RwLock<impl CoreApi + MgmtApi + RbacApi + Send + Sync>>,
) -> Result<(), AppError> {
let (domain_code, _, role_code) = self.check_domain_and_role(&domain, &role_id).await?;
let db = db_helper::get_db_connection().await?;
let permissions = SysEndpoint::find()
.filter(SysEndpointColumn::Id.is_in(permissions))
.all(db.as_ref())
.await
.map_err(AppError::from)?;
if permissions.is_empty() {
return Err(AuthorizationError::PermissionsNotFound.into());
}
self.sync_role_permissions(&role_code, &domain_code, permissions, enforcer)
.await?;
Ok(())
}
async fn assign_routes(
&self,
domain: String,
role_id: String,
route_ids: Vec<i32>,
) -> Result<(), AppError> {
let (domain_code, role_id, _) = self.check_domain_and_role(&domain, &role_id).await?;
let db = db_helper::get_db_connection().await?;
let routes = SysMenu::find()
.filter(SysMenuColumn::Id.is_in(route_ids.clone()))
.all(db.as_ref())
.await
.map_err(AppError::from)?;
if routes.is_empty() {
return Err(AuthorizationError::RoutesNotFound.into());
}
let existing_routes = SysRoleMenu::find()
.filter(
SysRoleMenuColumn::RoleId
.eq(&role_id)
.and(SysRoleMenuColumn::Domain.eq(&domain_code)),
)
.all(db.as_ref())
.await
.map_err(AppError::from)?;
let existing_route_ids: Vec<i32> = existing_routes.iter().map(|r| r.menu_id).collect();
let new_route_ids: Vec<i32> = route_ids
.iter()
.filter(|id| !existing_route_ids.contains(id))
.cloned()
.collect();
let route_ids_to_delete: Vec<i32> = existing_route_ids
.iter()
.filter(|id| !route_ids.contains(id))
.cloned()
.collect();
let txn = db.begin().await.map_err(AppError::from)?;
if !new_route_ids.is_empty() {
let role_menus: Vec<SysRoleMenuActiveModel> = new_route_ids
.iter()
.map(|route_id| SysRoleMenuActiveModel {
role_id: sea_orm::Set(role_id.clone()),
menu_id: sea_orm::Set(*route_id),
domain: sea_orm::Set(domain_code.clone()),
..Default::default()
})
.collect();
SysRoleMenu::insert_many(role_menus)
.exec(&txn)
.await
.map_err(AppError::from)?;
}
if !route_ids_to_delete.is_empty() {
SysRoleMenu::delete_many()
.filter(
SysRoleMenuColumn::RoleId
.eq(&role_id)
.and(SysRoleMenuColumn::Domain.eq(&domain_code))
.and(SysRoleMenuColumn::MenuId.is_in(route_ids_to_delete)),
)
.exec(&txn)
.await
.map_err(AppError::from)?;
}
txn.commit().await.map_err(AppError::from)?;
Ok(())
}
async fn assign_users(&self, role_id: String, user_ids: Vec<String>) -> Result<(), AppError> {
let _ = self.check_role(&role_id).await?;
let db = db_helper::get_db_connection().await?;
let users = SysUser::find()
.filter(server_model::admin::entities::sys_user::Column::Id.is_in(user_ids.clone()))
.all(db.as_ref())
.await
.map_err(AppError::from)?;
if users.is_empty() {
return Err(AuthorizationError::UsersNotFound.into());
}
let existing_user_roles = SysUserRole::find()
.filter(SysUserRoleColumn::RoleId.eq(&role_id))
.all(db.as_ref())
.await
.map_err(AppError::from)?;
let existing_user_ids: Vec<String> = existing_user_roles
.iter()
.map(|r| r.user_id.clone())
.collect();
let new_user_ids: Vec<String> = user_ids
.iter()
.filter(|id| !existing_user_ids.contains(id))
.cloned()
.collect();
let user_ids_to_delete: Vec<String> = existing_user_ids
.iter()
.filter(|id| !user_ids.contains(id))
.cloned()
.collect();
let txn = db.begin().await.map_err(AppError::from)?;
if !new_user_ids.is_empty() {
let user_roles: Vec<SysUserRoleActiveModel> = new_user_ids
.iter()
.map(|user_id| SysUserRoleActiveModel {
role_id: sea_orm::Set(role_id.clone()),
user_id: sea_orm::Set(user_id.clone()),
..Default::default()
})
.collect();
SysUserRole::insert_many(user_roles)
.exec(&txn)
.await
.map_err(AppError::from)?;
}
if !user_ids_to_delete.is_empty() {
SysUserRole::delete_many()
.filter(
SysUserRoleColumn::RoleId
.eq(&role_id)
.and(SysUserRoleColumn::UserId.is_in(user_ids_to_delete)),
)
.exec(&txn)
.await
.map_err(AppError::from)?;
}
txn.commit().await.map_err(AppError::from)?;
Ok(())
}
}
| rust | Apache-2.0 | a560191ee087ba509e2060f17937b9f2c8f9be33 | 2026-01-04T20:21:43.261270Z | false |
soybeanjs/soybean-admin-rust | https://github.com/soybeanjs/soybean-admin-rust/blob/a560191ee087ba509e2060f17937b9f2c8f9be33/server/service/src/admin/sys_login_log_service.rs | server/service/src/admin/sys_login_log_service.rs | use async_trait::async_trait;
use sea_orm::{ColumnTrait, Condition, EntityTrait, PaginatorTrait, QueryFilter, QueryOrder};
use server_core::web::{error::AppError, page::PaginatedData};
use server_model::admin::{
entities::{
prelude::SysLoginLog,
sys_login_log::{Column as SysLoginLogColumn, Model as SysLoginLogModel},
},
input::LoginLogPageRequest,
};
use crate::helper::db_helper;
#[async_trait]
pub trait TLoginLogService {
async fn find_paginated_login_logs(
&self,
params: LoginLogPageRequest,
) -> Result<PaginatedData<SysLoginLogModel>, AppError>;
}
pub struct SysLoginLogService;
#[async_trait]
impl TLoginLogService for SysLoginLogService {
async fn find_paginated_login_logs(
&self,
params: LoginLogPageRequest,
) -> Result<PaginatedData<SysLoginLogModel>, AppError> {
let db = db_helper::get_db_connection().await?;
let mut query = SysLoginLog::find();
if let Some(ref keywords) = params.keywords {
let condition = Condition::any()
.add(SysLoginLogColumn::Domain.contains(keywords))
.add(SysLoginLogColumn::Username.contains(keywords))
.add(SysLoginLogColumn::Ip.contains(keywords))
.add(SysLoginLogColumn::Address.contains(keywords))
.add(SysLoginLogColumn::UserAgent.contains(keywords));
query = query.filter(condition);
}
query = query.order_by_desc(SysLoginLogColumn::CreatedAt);
let total = query
.clone()
.count(db.as_ref())
.await
.map_err(AppError::from)?;
let paginator = query.paginate(db.as_ref(), params.page_details.size);
let records = paginator
.fetch_page(params.page_details.current - 1)
.await
.map_err(AppError::from)?;
Ok(PaginatedData {
current: params.page_details.current,
size: params.page_details.size,
total,
records,
})
}
}
| rust | Apache-2.0 | a560191ee087ba509e2060f17937b9f2c8f9be33 | 2026-01-04T20:21:43.261270Z | false |
soybeanjs/soybean-admin-rust | https://github.com/soybeanjs/soybean-admin-rust/blob/a560191ee087ba509e2060f17937b9f2c8f9be33/server/service/src/admin/sys_user_service.rs | server/service/src/admin/sys_user_service.rs | use async_trait::async_trait;
use chrono::Local;
use sea_orm::{
ActiveModelTrait, ColumnTrait, Condition, EntityTrait, IntoActiveModel, PaginatorTrait,
QueryFilter, Set,
};
use server_core::web::{error::AppError, page::PaginatedData};
use server_model::admin::{
entities::{
prelude::SysUser,
sys_user::{
ActiveModel as SysUserActiveModel, Column as SysUserColumn, Model as SysUserModel,
},
},
input::{CreateUserInput, UpdateUserInput, UserPageRequest},
output::UserWithoutPassword,
};
use server_utils::SecureUtil;
use ulid::Ulid;
use super::sys_user_error::UserError;
use crate::helper::db_helper;
#[async_trait]
pub trait TUserService {
async fn find_all(&self) -> Result<Vec<UserWithoutPassword>, AppError>;
async fn find_paginated_users(
&self,
params: UserPageRequest,
) -> Result<PaginatedData<UserWithoutPassword>, AppError>;
async fn create_user(&self, input: CreateUserInput) -> Result<UserWithoutPassword, AppError>;
async fn get_user(&self, id: &str) -> Result<UserWithoutPassword, AppError>;
async fn update_user(&self, input: UpdateUserInput) -> Result<UserWithoutPassword, AppError>;
async fn delete_user(&self, id: &str) -> Result<(), AppError>;
}
#[derive(Clone)]
pub struct SysUserService;
impl SysUserService {
async fn check_username_unique(&self, username: &str) -> Result<(), AppError> {
let db = db_helper::get_db_connection().await?;
let existing_user = SysUser::find()
.filter(SysUserColumn::Username.eq(username))
.one(db.as_ref())
.await
.map_err(AppError::from)?;
if existing_user.is_some() {
return Err(UserError::UsernameAlreadyExists.into());
}
Ok(())
}
async fn get_user_by_id(&self, id: String) -> Result<SysUserModel, AppError> {
let db = db_helper::get_db_connection().await?;
SysUser::find_by_id(id)
.one(db.as_ref())
.await
.map_err(AppError::from)?
.ok_or_else(|| UserError::UserNotFound.into())
}
}
#[async_trait]
impl TUserService for SysUserService {
async fn find_all(&self) -> Result<Vec<UserWithoutPassword>, AppError> {
let db = db_helper::get_db_connection().await?;
SysUser::find()
.all(db.as_ref())
.await
.map(|users| users.into_iter().map(UserWithoutPassword::from).collect())
.map_err(AppError::from)
}
async fn find_paginated_users(
&self,
params: UserPageRequest,
) -> Result<PaginatedData<UserWithoutPassword>, AppError> {
let db = db_helper::get_db_connection().await?;
let mut query = SysUser::find();
if let Some(ref keywords) = params.keywords {
let condition = Condition::any().add(SysUserColumn::Username.contains(keywords));
query = query.filter(condition);
}
let total = query
.clone()
.count(db.as_ref())
.await
.map_err(AppError::from)?;
let paginator = query.paginate(db.as_ref(), params.page_details.size);
let records = paginator
.fetch_page(params.page_details.current - 1)
.await
.map_err(AppError::from)?
.into_iter()
.map(UserWithoutPassword::from)
.collect();
Ok(PaginatedData {
current: params.page_details.current,
size: params.page_details.size,
total,
records,
})
}
async fn create_user(&self, input: CreateUserInput) -> Result<UserWithoutPassword, AppError> {
self.check_username_unique(&input.username).await?;
let db = db_helper::get_db_connection().await?;
let user = SysUserActiveModel {
id: Set(Ulid::new().to_string()),
domain: Set(input.domain),
username: Set(input.username),
password: Set(SecureUtil::hash_password(input.password.as_bytes()).unwrap()),
built_in: Set(false),
nick_name: Set(input.nick_name),
avatar: Set(input.avatar),
email: Set(input.email),
phone_number: Set(input.phone_number),
status: Set(input.status),
created_at: Set(Local::now().naive_local()),
created_by: Set("TODO".to_string()),
..Default::default()
};
let user_model = user.insert(db.as_ref()).await.map_err(AppError::from)?;
Ok(UserWithoutPassword::from(user_model))
}
async fn get_user(&self, id: &str) -> Result<UserWithoutPassword, AppError> {
let db = db_helper::get_db_connection().await?;
SysUser::find_by_id(id)
.one(db.as_ref())
.await
.map_err(AppError::from)?
.map(UserWithoutPassword::from)
.ok_or_else(|| UserError::UserNotFound.into())
}
async fn update_user(&self, input: UpdateUserInput) -> Result<UserWithoutPassword, AppError> {
let mut user = self.get_user_by_id(input.id).await?.into_active_model();
if input.user.username != *user.username.as_ref() {
self.check_username_unique(&input.user.username).await?;
}
user.domain = Set(input.user.domain);
user.username = Set(input.user.username);
user.password = Set(input.user.password); // TODO: Note: In a real application, you should hash the password
user.nick_name = Set(input.user.nick_name);
user.avatar = Set(input.user.avatar);
user.email = Set(input.user.email);
user.phone_number = Set(input.user.phone_number);
user.status = Set(input.user.status);
let db = db_helper::get_db_connection().await?;
let updated_user = user.update(db.as_ref()).await.map_err(AppError::from)?;
Ok(UserWithoutPassword::from(updated_user))
}
async fn delete_user(&self, id: &str) -> Result<(), AppError> {
let db = db_helper::get_db_connection().await?;
let result = SysUser::delete_by_id(id)
.exec(db.as_ref())
.await
.map_err(AppError::from)?;
if result.rows_affected == 0 {
return Err(UserError::UserNotFound.into());
}
Ok(())
}
}
| rust | Apache-2.0 | a560191ee087ba509e2060f17937b9f2c8f9be33 | 2026-01-04T20:21:43.261270Z | false |
soybeanjs/soybean-admin-rust | https://github.com/soybeanjs/soybean-admin-rust/blob/a560191ee087ba509e2060f17937b9f2c8f9be33/server/service/src/admin/sys_menu_service.rs | server/service/src/admin/sys_menu_service.rs | use async_trait::async_trait;
use chrono::Local;
use sea_orm::{ActiveModelTrait, ColumnTrait, Condition, EntityTrait, QueryFilter, Set};
use server_core::web::{auth::User, error::AppError};
use server_model::admin::{
entities::{
prelude::{SysMenu, SysRoleMenu},
sea_orm_active_enums::Status,
sys_menu::{
ActiveModel as SysMenuActiveModel, Column as SysMenuColumn, Model as SysMenuModel,
},
sys_role_menu::Column as SysRoleMenuColumn,
},
input::{CreateMenuInput, UpdateMenuInput},
output::{MenuRoute, MenuTree, RouteMeta},
};
use server_utils::TreeBuilder;
use crate::{admin::sys_menu_error::MenuError, helper::db_helper};
#[async_trait]
pub trait TMenuService {
async fn tree_menu(&self) -> Result<Vec<MenuTree>, AppError>;
async fn get_menu_list(&self) -> Result<Vec<MenuTree>, AppError>;
async fn get_constant_routes(&self) -> Result<Vec<MenuRoute>, AppError>;
async fn create_menu(
&self,
input: CreateMenuInput,
user: User,
) -> Result<SysMenuModel, AppError>;
async fn get_menu(&self, id: i32) -> Result<SysMenuModel, AppError>;
async fn update_menu(
&self,
input: UpdateMenuInput,
user: User,
) -> Result<SysMenuModel, AppError>;
async fn delete_menu(&self, id: i32, user: User) -> Result<(), AppError>;
async fn get_menu_ids_by_role_id(
&self,
role_id: String,
domain: String,
) -> Result<Vec<i32>, AppError>;
}
#[derive(Clone)]
pub struct SysMenuService;
impl SysMenuService {
fn build_menu_tree(menu: &SysMenuModel) -> MenuTree {
MenuTree {
id: menu.id,
pid: menu.pid.clone(),
menu_type: menu.menu_type.clone(),
menu_name: menu.menu_name.clone(),
icon_type: menu.icon_type.clone(),
icon: menu.icon.clone(),
route_name: menu.route_name.clone(),
route_path: menu.route_path.clone(),
component: menu.component.clone(),
path_param: menu.path_param.clone(),
status: menu.status.clone(),
active_menu: menu.active_menu.clone(),
hide_in_menu: menu.hide_in_menu,
sequence: menu.sequence,
i18n_key: menu.i18n_key.clone(),
keep_alive: menu.keep_alive,
constant: menu.constant,
href: menu.href.clone(),
multi_tab: menu.multi_tab,
created_at: menu.created_at,
created_by: menu.created_by.clone(),
updated_at: menu.updated_at,
updated_by: menu.updated_by.clone(),
children: None,
}
}
fn build_tree_structure(menu_trees: Vec<MenuTree>) -> Vec<MenuTree> {
TreeBuilder::build(
menu_trees,
|node| node.id,
|node| {
if node.pid == "0" {
None
} else {
Some(node.pid.parse::<i32>().unwrap_or(-1))
}
},
|node| node.sequence,
|node, children| node.children = Some(children),
)
}
async fn check_menu_exists(&self, id: Option<i32>, route_name: &str) -> Result<(), AppError> {
let db = db_helper::get_db_connection().await?;
let route_name_exists = SysMenu::find()
.filter(SysMenuColumn::RouteName.eq(route_name))
.filter(SysMenuColumn::Id.ne(id.unwrap_or(-1)))
.one(db.as_ref())
.await
.map_err(AppError::from)?
.is_some();
if route_name_exists {
return Err(MenuError::DuplicateRouteName.into());
}
Ok(())
}
}
#[async_trait]
impl TMenuService for SysMenuService {
async fn tree_menu(&self) -> Result<Vec<MenuTree>, AppError> {
let db = db_helper::get_db_connection().await?;
let menus = SysMenu::find()
.filter(SysMenuColumn::Constant.eq(false))
.filter(SysMenuColumn::Status.eq(Status::Enabled))
.all(db.as_ref())
.await
.map_err(AppError::from)?;
let menu_trees: Vec<MenuTree> = menus.iter().map(Self::build_menu_tree).collect();
Ok(Self::build_tree_structure(menu_trees))
}
async fn get_menu_list(&self) -> Result<Vec<MenuTree>, AppError> {
let db = db_helper::get_db_connection().await?;
let menus = SysMenu::find()
.all(db.as_ref())
.await
.map_err(AppError::from)?;
let menu_trees: Vec<MenuTree> = menus.iter().map(Self::build_menu_tree).collect();
Ok(Self::build_tree_structure(menu_trees))
}
async fn get_constant_routes(&self) -> Result<Vec<MenuRoute>, AppError> {
let db = db_helper::get_db_connection().await?;
let menus: Vec<SysMenuModel> = SysMenu::find()
.filter(SysMenuColumn::Constant.eq(true))
.filter(SysMenuColumn::Status.eq(Status::Enabled))
.all(db.as_ref())
.await
.map_err(AppError::from)?;
let result = menus
.into_iter()
.map(|menu| MenuRoute {
id: menu.id,
pid: menu.pid,
name: menu.route_name,
path: menu.route_path,
component: menu.component,
meta: RouteMeta {
title: menu.menu_name,
i18n_key: menu.i18n_key,
keep_alive: menu.keep_alive,
constant: menu.constant,
icon: menu.icon,
order: menu.sequence,
href: menu.href,
hide_in_menu: menu.hide_in_menu,
active_menu: menu.active_menu,
multi_tab: menu.multi_tab,
},
children: vec![].into(),
})
.collect();
Ok(result)
}
async fn create_menu(
&self,
input: CreateMenuInput,
user: User,
) -> Result<SysMenuModel, AppError> {
self.check_menu_exists(None, &input.route_name).await?;
let db = db_helper::get_db_connection().await?;
let menu = SysMenuActiveModel {
menu_type: Set(input.menu_type),
menu_name: Set(input.menu_name),
icon_type: Set(input.icon_type),
icon: Set(input.icon),
route_name: Set(input.route_name),
route_path: Set(input.route_path),
component: Set(input.component),
path_param: Set(input.path_param),
status: Set(input.status),
active_menu: Set(input.active_menu),
hide_in_menu: Set(input.hide_in_menu),
pid: Set(input.pid),
sequence: Set(input.sequence),
i18n_key: Set(input.i18n_key),
keep_alive: Set(input.keep_alive),
constant: Set(input.constant),
href: Set(input.href),
multi_tab: Set(input.multi_tab),
created_by: Set(user.user_id()),
..Default::default()
};
let result = menu.insert(db.as_ref()).await.map_err(AppError::from)?;
Ok(result)
}
async fn get_menu(&self, id: i32) -> Result<SysMenuModel, AppError> {
let db = db_helper::get_db_connection().await?;
SysMenu::find_by_id(id)
.one(db.as_ref())
.await
.map_err(AppError::from)?
.ok_or_else(|| MenuError::MenuNotFound.into())
}
async fn update_menu(
&self,
input: UpdateMenuInput,
user: User,
) -> Result<SysMenuModel, AppError> {
let db = db_helper::get_db_connection().await?;
let existing_menu = self.get_menu(input.id).await?;
self.check_menu_exists(Some(input.id), &input.menu.route_name)
.await?;
let mut menu: SysMenuActiveModel = existing_menu.into();
menu.menu_type = Set(input.menu.menu_type);
menu.menu_name = Set(input.menu.menu_name);
menu.icon_type = Set(input.menu.icon_type);
menu.icon = Set(input.menu.icon);
menu.route_name = Set(input.menu.route_name);
menu.route_path = Set(input.menu.route_path);
menu.component = Set(input.menu.component);
menu.path_param = Set(input.menu.path_param);
menu.status = Set(input.menu.status);
menu.active_menu = Set(input.menu.active_menu);
menu.hide_in_menu = Set(input.menu.hide_in_menu);
menu.pid = Set(input.menu.pid);
menu.sequence = Set(input.menu.sequence);
menu.i18n_key = Set(input.menu.i18n_key);
menu.keep_alive = Set(input.menu.keep_alive);
menu.constant = Set(input.menu.constant);
menu.href = Set(input.menu.href);
menu.multi_tab = Set(input.menu.multi_tab);
menu.updated_at = Set(Some(Local::now().naive_local()));
menu.updated_by = Set(Some(user.user_id()));
let updated_menu = menu.update(db.as_ref()).await.map_err(AppError::from)?;
Ok(updated_menu)
}
async fn delete_menu(&self, id: i32, _user: User) -> Result<(), AppError> {
let db = db_helper::get_db_connection().await?;
SysMenu::delete_by_id(id)
.exec(db.as_ref())
.await
.map_err(AppError::from)?;
Ok(())
}
async fn get_menu_ids_by_role_id(
&self,
role_id: String,
domain: String,
) -> Result<Vec<i32>, AppError> {
let db = db_helper::get_db_connection().await?;
let role_menus = SysRoleMenu::find()
.filter(
Condition::all()
.add(SysRoleMenuColumn::RoleId.eq(role_id))
.add(SysRoleMenuColumn::Domain.eq(domain)),
)
.all(db.as_ref())
.await
.map_err(AppError::from)?;
let menu_ids: Vec<i32> = role_menus.iter().map(|rm| rm.menu_id).collect();
if menu_ids.is_empty() {
return Ok(vec![]);
}
let menus = SysMenu::find()
.filter(
Condition::all()
.add(SysMenuColumn::Id.is_in(menu_ids))
.add(SysMenuColumn::Status.eq(Status::Enabled))
.add(SysMenuColumn::Constant.eq(false)),
)
.all(db.as_ref())
.await
.map_err(AppError::from)?;
Ok(menus.iter().map(|menu| menu.id).collect())
}
}
| rust | Apache-2.0 | a560191ee087ba509e2060f17937b9f2c8f9be33 | 2026-01-04T20:21:43.261270Z | false |
soybeanjs/soybean-admin-rust | https://github.com/soybeanjs/soybean-admin-rust/blob/a560191ee087ba509e2060f17937b9f2c8f9be33/server/service/src/admin/dto/mod.rs | server/service/src/admin/dto/mod.rs | pub mod sys_auth_dto;
| rust | Apache-2.0 | a560191ee087ba509e2060f17937b9f2c8f9be33 | 2026-01-04T20:21:43.261270Z | false |
soybeanjs/soybean-admin-rust | https://github.com/soybeanjs/soybean-admin-rust/blob/a560191ee087ba509e2060f17937b9f2c8f9be33/server/service/src/admin/dto/sys_auth_dto.rs | server/service/src/admin/dto/sys_auth_dto.rs | use server_constant::definition::Audience;
#[derive(Clone, Debug)]
pub struct LoginContext {
pub client_ip: String,
pub client_port: Option<i32>,
pub address: String,
pub user_agent: String,
pub request_id: String,
pub audience: Audience,
pub login_type: String,
pub domain: String,
}
| rust | Apache-2.0 | a560191ee087ba509e2060f17937b9f2c8f9be33 | 2026-01-04T20:21:43.261270Z | false |
soybeanjs/soybean-admin-rust | https://github.com/soybeanjs/soybean-admin-rust/blob/a560191ee087ba509e2060f17937b9f2c8f9be33/server/service/src/admin/errors/sys_domain_error.rs | server/service/src/admin/errors/sys_domain_error.rs | use server_core::web::error::{ApiError, AppError};
use thiserror::Error;
#[derive(Error, Debug)]
pub enum DomainError {
#[error("Domain not found")]
DomainNotFound,
#[error("Domain with this code already exists")]
DuplicateCode,
#[error("Domain with this name already exists")]
DuplicateName,
#[error("Cannot modify or delete built-in domain")]
BuiltInDomain,
}
impl ApiError for DomainError {
fn code(&self) -> u16 {
match self {
DomainError::DomainNotFound => 2001,
DomainError::DuplicateCode => 2002,
DomainError::DuplicateName => 2003,
DomainError::BuiltInDomain => 2004,
}
}
fn message(&self) -> String {
format!("{}", self)
}
}
impl From<DomainError> for AppError {
fn from(err: DomainError) -> Self {
AppError {
code: err.code(),
message: err.message(),
}
}
}
| rust | Apache-2.0 | a560191ee087ba509e2060f17937b9f2c8f9be33 | 2026-01-04T20:21:43.261270Z | false |
soybeanjs/soybean-admin-rust | https://github.com/soybeanjs/soybean-admin-rust/blob/a560191ee087ba509e2060f17937b9f2c8f9be33/server/service/src/admin/errors/sys_user_error.rs | server/service/src/admin/errors/sys_user_error.rs | use server_core::web::error::{ApiError, AppError};
use thiserror::Error;
#[derive(Error, Debug)]
pub enum UserError {
#[error("User not found")]
UserNotFound,
#[error("Authentication failed: Wrong password")]
WrongPassword,
#[error("Authentication failed")]
AuthenticationFailed,
#[error("Username already exists")]
UsernameAlreadyExists,
#[error("Invalid user status")]
InvalidUserStatus,
}
impl ApiError for UserError {
fn code(&self) -> u16 {
match self {
UserError::UserNotFound => 1001,
UserError::WrongPassword => 1002,
UserError::AuthenticationFailed => 1003,
UserError::UsernameAlreadyExists => 1004,
UserError::InvalidUserStatus => 1005,
}
}
fn message(&self) -> String {
format!("{}", self)
}
}
impl From<UserError> for AppError {
fn from(err: UserError) -> Self {
AppError {
code: err.code(),
message: err.message(),
}
}
}
| rust | Apache-2.0 | a560191ee087ba509e2060f17937b9f2c8f9be33 | 2026-01-04T20:21:43.261270Z | false |
soybeanjs/soybean-admin-rust | https://github.com/soybeanjs/soybean-admin-rust/blob/a560191ee087ba509e2060f17937b9f2c8f9be33/server/service/src/admin/errors/mod.rs | server/service/src/admin/errors/mod.rs | pub mod sys_access_key_error;
pub mod sys_domain_error;
pub mod sys_menu_error;
pub mod sys_role_error;
pub mod sys_user_error;
| rust | Apache-2.0 | a560191ee087ba509e2060f17937b9f2c8f9be33 | 2026-01-04T20:21:43.261270Z | false |
soybeanjs/soybean-admin-rust | https://github.com/soybeanjs/soybean-admin-rust/blob/a560191ee087ba509e2060f17937b9f2c8f9be33/server/service/src/admin/errors/sys_access_key_error.rs | server/service/src/admin/errors/sys_access_key_error.rs | use server_core::web::error::{ApiError, AppError};
use thiserror::Error;
#[derive(Error, Debug)]
pub enum AccessKeyError {
#[error("Access key not found")]
AccessKeyNotFound,
}
impl ApiError for AccessKeyError {
fn code(&self) -> u16 {
match self {
AccessKeyError::AccessKeyNotFound => 5001,
}
}
fn message(&self) -> String {
format!("{}", self)
}
}
impl From<AccessKeyError> for AppError {
fn from(err: AccessKeyError) -> Self {
AppError {
code: err.code(),
message: err.message(),
}
}
}
| rust | Apache-2.0 | a560191ee087ba509e2060f17937b9f2c8f9be33 | 2026-01-04T20:21:43.261270Z | false |
soybeanjs/soybean-admin-rust | https://github.com/soybeanjs/soybean-admin-rust/blob/a560191ee087ba509e2060f17937b9f2c8f9be33/server/service/src/admin/errors/sys_role_error.rs | server/service/src/admin/errors/sys_role_error.rs | use server_core::web::error::{ApiError, AppError};
use thiserror::Error;
#[derive(Debug, Error)]
pub enum RoleError {
#[error("Role not found")]
RoleNotFound,
#[error("Duplicate role code")]
DuplicateRoleCode,
}
impl ApiError for RoleError {
fn code(&self) -> u16 {
match self {
RoleError::RoleNotFound => 4001,
RoleError::DuplicateRoleCode => 4002,
}
}
fn message(&self) -> String {
format!("{}", self)
}
}
impl From<RoleError> for AppError {
fn from(err: RoleError) -> Self {
AppError {
code: err.code(),
message: err.message(),
}
}
}
| rust | Apache-2.0 | a560191ee087ba509e2060f17937b9f2c8f9be33 | 2026-01-04T20:21:43.261270Z | false |
soybeanjs/soybean-admin-rust | https://github.com/soybeanjs/soybean-admin-rust/blob/a560191ee087ba509e2060f17937b9f2c8f9be33/server/service/src/admin/errors/sys_menu_error.rs | server/service/src/admin/errors/sys_menu_error.rs | use server_core::web::error::{ApiError, AppError};
use thiserror::Error;
#[derive(Debug, Error)]
pub enum MenuError {
#[error("Menu not found")]
MenuNotFound,
#[error("Duplicate route name")]
DuplicateRouteName,
}
impl ApiError for MenuError {
fn code(&self) -> u16 {
match self {
MenuError::MenuNotFound => 3001,
MenuError::DuplicateRouteName => 3002,
}
}
fn message(&self) -> String {
format!("{}", self)
}
}
impl From<MenuError> for AppError {
fn from(err: MenuError) -> Self {
AppError {
code: err.code(),
message: err.message(),
}
}
}
| rust | Apache-2.0 | a560191ee087ba509e2060f17937b9f2c8f9be33 | 2026-01-04T20:21:43.261270Z | false |
soybeanjs/soybean-admin-rust | https://github.com/soybeanjs/soybean-admin-rust/blob/a560191ee087ba509e2060f17937b9f2c8f9be33/server/service/src/admin/events/login_log_event.rs | server/service/src/admin/events/login_log_event.rs | use chrono::Local;
use sea_orm::{ActiveModelTrait, DatabaseConnection, Set};
use server_core::web::error::AppError;
use server_model::admin::entities::sys_login_log::ActiveModel as SysLoginLogActiveModel;
use ulid::Ulid;
pub struct LoginLogEvent {
pub user_id: String,
pub username: String,
pub domain: String,
pub ip: String,
pub port: Option<i32>,
pub address: String,
pub user_agent: String,
pub request_id: String,
pub login_type: String,
}
impl LoginLogEvent {
pub async fn handle(self, db: &DatabaseConnection) -> Result<(), AppError> {
SysLoginLogActiveModel {
id: Set(Ulid::new().to_string()),
user_id: Set(self.user_id),
username: Set(self.username.clone()),
domain: Set(self.domain),
login_time: Set(Local::now().naive_local()),
ip: Set(self.ip),
port: Set(self.port),
address: Set(self.address),
user_agent: Set(self.user_agent),
request_id: Set(self.request_id),
r#type: Set(self.login_type),
created_at: Set(Local::now().naive_local()),
created_by: Set(self.username),
}
.insert(db)
.await
.map_err(AppError::from)?;
Ok(())
}
}
| rust | Apache-2.0 | a560191ee087ba509e2060f17937b9f2c8f9be33 | 2026-01-04T20:21:43.261270Z | false |
soybeanjs/soybean-admin-rust | https://github.com/soybeanjs/soybean-admin-rust/blob/a560191ee087ba509e2060f17937b9f2c8f9be33/server/service/src/admin/events/access_token_event.rs | server/service/src/admin/events/access_token_event.rs | use chrono::Local;
use sea_orm::{ActiveModelTrait, DatabaseConnection, Set};
use server_constant::definition::consts::TokenStatus;
use server_core::web::error::AppError;
use server_model::admin::entities::sys_tokens::ActiveModel as SysTokensActiveModel;
use ulid::Ulid;
pub struct AccessTokenEvent {
pub access_token: String,
pub refresh_token: String,
pub user_id: String,
pub username: String,
pub domain: String,
pub ip: String,
pub port: Option<i32>,
pub address: String,
pub user_agent: String,
pub request_id: String,
pub login_type: String,
}
impl AccessTokenEvent {
pub async fn handle(self, db: &DatabaseConnection) -> Result<(), AppError> {
let now = Local::now().naive_local();
SysTokensActiveModel {
id: Set(Ulid::new().to_string()),
access_token: Set(self.access_token),
refresh_token: Set(self.refresh_token),
status: Set(TokenStatus::Active.to_string()),
user_id: Set(self.user_id),
username: Set(self.username.clone()),
domain: Set(self.domain),
login_time: Set(now),
ip: Set(self.ip),
port: Set(self.port),
address: Set(self.address),
user_agent: Set(self.user_agent),
request_id: Set(self.request_id),
r#type: Set(self.login_type),
created_at: Set(now),
created_by: Set(self.username),
}
.insert(db)
.await
.map_err(AppError::from)?;
Ok(())
}
}
| rust | Apache-2.0 | a560191ee087ba509e2060f17937b9f2c8f9be33 | 2026-01-04T20:21:43.261270Z | false |
soybeanjs/soybean-admin-rust | https://github.com/soybeanjs/soybean-admin-rust/blob/a560191ee087ba509e2060f17937b9f2c8f9be33/server/service/src/admin/events/mod.rs | server/service/src/admin/events/mod.rs | pub mod access_token_event;
pub mod login_log_event;
| rust | Apache-2.0 | a560191ee087ba509e2060f17937b9f2c8f9be33 | 2026-01-04T20:21:43.261270Z | false |
soybeanjs/soybean-admin-rust | https://github.com/soybeanjs/soybean-admin-rust/blob/a560191ee087ba509e2060f17937b9f2c8f9be33/server/service/src/admin/event_handlers/auth_event_handler.rs | server/service/src/admin/event_handlers/auth_event_handler.rs | use server_core::web::error::AppError;
use crate::{
admin::events::{access_token_event::AccessTokenEvent, login_log_event::LoginLogEvent},
helper::db_helper,
};
pub struct AuthEvent {
pub user_id: String,
pub username: String,
pub domain: String,
pub access_token: String,
pub refresh_token: String,
pub client_ip: String,
pub client_port: Option<i32>,
pub address: String,
pub user_agent: String,
pub request_id: String,
pub login_type: String,
}
pub struct AuthEventHandler;
impl AuthEventHandler {
pub async fn handle_login(event: AuthEvent) -> Result<(), AppError> {
let db = db_helper::get_db_connection().await?;
// 处理登录日志
let login_log_event = LoginLogEvent {
user_id: event.user_id.clone(),
username: event.username.clone(),
domain: event.domain.clone(),
ip: event.client_ip.clone(),
port: event.client_port,
address: event.address.clone(),
user_agent: event.user_agent.clone(),
request_id: event.request_id.clone(),
login_type: event.login_type.clone(),
};
login_log_event.handle(&db).await?;
// 处理访问令牌
let access_token_event = AccessTokenEvent {
access_token: event.access_token,
refresh_token: event.refresh_token,
user_id: event.user_id,
username: event.username,
domain: event.domain,
ip: event.client_ip,
port: event.client_port,
address: event.address.clone(),
user_agent: event.user_agent,
request_id: event.request_id,
login_type: event.login_type,
};
access_token_event.handle(&db).await?;
Ok(())
}
}
| rust | Apache-2.0 | a560191ee087ba509e2060f17937b9f2c8f9be33 | 2026-01-04T20:21:43.261270Z | false |
soybeanjs/soybean-admin-rust | https://github.com/soybeanjs/soybean-admin-rust/blob/a560191ee087ba509e2060f17937b9f2c8f9be33/server/service/src/admin/event_handlers/mod.rs | server/service/src/admin/event_handlers/mod.rs | pub mod auth_event_handler;
| rust | Apache-2.0 | a560191ee087ba509e2060f17937b9f2c8f9be33 | 2026-01-04T20:21:43.261270Z | false |
soybeanjs/soybean-admin-rust | https://github.com/soybeanjs/soybean-admin-rust/blob/a560191ee087ba509e2060f17937b9f2c8f9be33/server/service/src/helper/redis_helper.rs | server/service/src/helper/redis_helper.rs | #![allow(dead_code)]
use redis::{aio::MultiplexedConnection, cluster_async::ClusterConnection, ErrorKind, RedisError};
use server_core::web::error::AppError;
use server_global::global::{RedisConnection, GLOBAL_PRIMARY_REDIS, GLOBAL_REDIS_POOL};
/// Redis连接来源
#[derive(Debug, Clone)]
pub enum RedisSource {
/// 主Redis实例
Primary,
/// 命名的Redis实例
Named(String),
}
/// 获取Redis连接
pub async fn get_redis_connection(source: RedisSource) -> Result<MultiplexedConnection, AppError> {
match source {
RedisSource::Primary => {
let redis = GLOBAL_PRIMARY_REDIS.read().await.clone().ok_or_else(|| {
AppError::from(RedisError::from((
ErrorKind::IoError,
"Primary Redis not initialized",
)))
})?;
match redis {
RedisConnection::Single(client) => {
Ok(client.get_multiplexed_async_connection().await?)
},
RedisConnection::Cluster(_) => Err(AppError::from(RedisError::from((
ErrorKind::IoError,
"Primary Redis is not Single mode",
)))),
}
},
RedisSource::Named(name) => {
let pools = GLOBAL_REDIS_POOL.read().await;
let redis = pools.get(&name).ok_or_else(|| {
AppError::from(RedisError::from((
ErrorKind::IoError,
"Redis pool not found",
)))
})?;
match redis {
RedisConnection::Single(client) => {
Ok(client.get_multiplexed_async_connection().await?)
},
RedisConnection::Cluster(_) => Err(AppError::from(RedisError::from((
ErrorKind::IoError,
"Named Redis is not Single mode",
)))),
}
},
}
}
/// 获取Redis集群连接
pub async fn get_redis_cluster_connection(
source: RedisSource,
) -> Result<ClusterConnection, AppError> {
match source {
RedisSource::Primary => {
let redis = GLOBAL_PRIMARY_REDIS.read().await.clone().ok_or_else(|| {
AppError::from(RedisError::from((
ErrorKind::IoError,
"Primary Redis not initialized",
)))
})?;
match redis {
RedisConnection::Single(_) => Err(AppError::from(RedisError::from((
ErrorKind::IoError,
"Primary Redis is not Cluster mode",
)))),
RedisConnection::Cluster(client) => Ok(client.get_async_connection().await?),
}
},
RedisSource::Named(name) => {
let pools = GLOBAL_REDIS_POOL.read().await;
let redis = pools.get(&name).ok_or_else(|| {
AppError::from(RedisError::from((
ErrorKind::IoError,
"Redis pool not found",
)))
})?;
match redis {
RedisConnection::Single(_) => Err(AppError::from(RedisError::from((
ErrorKind::IoError,
"Named Redis is not Cluster mode",
)))),
RedisConnection::Cluster(client) => Ok(client.get_async_connection().await?),
}
},
}
}
| rust | Apache-2.0 | a560191ee087ba509e2060f17937b9f2c8f9be33 | 2026-01-04T20:21:43.261270Z | false |
soybeanjs/soybean-admin-rust | https://github.com/soybeanjs/soybean-admin-rust/blob/a560191ee087ba509e2060f17937b9f2c8f9be33/server/service/src/helper/db_helper.rs | server/service/src/helper/db_helper.rs | use std::sync::Arc;
use sea_orm::{ConnAcquireErr, DatabaseConnection, DbErr};
use server_core::web::error::AppError;
use server_global::global::{GLOBAL_DB_POOL, GLOBAL_PRIMARY_DB};
pub async fn get_db_connection() -> Result<Arc<DatabaseConnection>, AppError> {
let db = GLOBAL_PRIMARY_DB.read().await;
db.as_ref()
.cloned()
.ok_or_else(|| AppError::from(DbErr::ConnectionAcquire(ConnAcquireErr::Timeout)))
}
/// 获取命名数据库连接
#[allow(dead_code)]
pub async fn get_named_connection(name: &str) -> Result<Arc<DatabaseConnection>, AppError> {
let pools = GLOBAL_DB_POOL.read().await;
let db = pools.get(name).ok_or_else(|| AppError {
code: 500,
message: format!("Database pool '{}' not found", name),
})?;
Ok(db.clone())
}
| rust | Apache-2.0 | a560191ee087ba509e2060f17937b9f2c8f9be33 | 2026-01-04T20:21:43.261270Z | false |
soybeanjs/soybean-admin-rust | https://github.com/soybeanjs/soybean-admin-rust/blob/a560191ee087ba509e2060f17937b9f2c8f9be33/server/service/src/helper/mod.rs | server/service/src/helper/mod.rs | pub mod db_helper;
pub mod mongo_helper;
pub mod redis_helper;
| rust | Apache-2.0 | a560191ee087ba509e2060f17937b9f2c8f9be33 | 2026-01-04T20:21:43.261270Z | false |
soybeanjs/soybean-admin-rust | https://github.com/soybeanjs/soybean-admin-rust/blob/a560191ee087ba509e2060f17937b9f2c8f9be33/server/service/src/helper/mongo_helper.rs | server/service/src/helper/mongo_helper.rs | #![allow(dead_code)]
use mongodb::{Client, Collection};
use server_core::web::error::AppError;
use server_global::global::{GLOBAL_MONGO_POOL, GLOBAL_PRIMARY_MONGO};
/// MongoDB 连接来源
#[derive(Debug, Clone)]
pub enum MongoSource {
/// 主 MongoDB 实例
Primary,
/// 命名的 MongoDB 实例
Named(String),
}
// ===== 主数据库操作 =====
/// 获取主 MongoDB 客户端
pub async fn get_primary_client() -> Result<Client, AppError> {
let client = GLOBAL_PRIMARY_MONGO
.read()
.await
.clone()
.ok_or_else(|| AppError {
code: 500,
message: "Primary MongoDB not initialized".to_string(),
})?;
Ok(client.as_ref().clone())
}
/// 获取主 MongoDB 指定数据库的集合
pub async fn get_primary_collection<T: Send + Sync>(
db_name: &str,
coll_name: &str,
) -> Result<Collection<T>, AppError> {
let client = get_primary_client().await?;
Ok(client.database(db_name).collection(coll_name))
}
// ===== 命名数据库操作 =====
/// 获取命名 MongoDB 客户端
pub async fn get_named_client(name: &str) -> Result<Client, AppError> {
let pools = GLOBAL_MONGO_POOL.read().await;
let client = pools.get(name).ok_or_else(|| AppError {
code: 500,
message: format!("MongoDB pool '{}' not found", name),
})?;
Ok(client.as_ref().clone())
}
/// 获取命名 MongoDB 指定数据库的集合
pub async fn get_named_collection<T: Send + Sync>(
pool_name: &str,
db_name: &str,
coll_name: &str,
) -> Result<Collection<T>, AppError> {
let client = get_named_client(pool_name).await?;
Ok(client.database(db_name).collection(coll_name))
}
// ===== 通用接口 =====
/// 获取 MongoDB 客户端
pub async fn get_client(source: MongoSource) -> Result<Client, AppError> {
match source {
MongoSource::Primary => get_primary_client().await,
MongoSource::Named(name) => get_named_client(&name).await,
}
}
/// 获取 MongoDB 集合
pub async fn get_collection<T: Send + Sync>(
source: MongoSource,
db_name: &str,
coll_name: &str,
) -> Result<Collection<T>, AppError> {
match source {
MongoSource::Primary => get_primary_collection(db_name, coll_name).await,
MongoSource::Named(name) => get_named_collection(&name, db_name, coll_name).await,
}
}
| rust | Apache-2.0 | a560191ee087ba509e2060f17937b9f2c8f9be33 | 2026-01-04T20:21:43.261270Z | false |
soybeanjs/soybean-admin-rust | https://github.com/soybeanjs/soybean-admin-rust/blob/a560191ee087ba509e2060f17937b9f2c8f9be33/server/global/src/global.rs | server/global/src/global.rs | use std::{
any::{Any, TypeId},
collections::HashMap,
future::Future,
pin::Pin,
sync::Arc,
};
use aws_sdk_s3::Client as S3Client;
use chrono::NaiveDateTime;
use http::Method;
use jsonwebtoken::{DecodingKey, EncodingKey, Validation};
use mongodb::Client as MongoClient;
use once_cell::sync::Lazy;
use redis::{cluster::ClusterClient, Client};
use sea_orm::DatabaseConnection;
use serde_json::Value;
use tokio::sync::{mpsc, Mutex, OnceCell, RwLock};
use crate::project_info;
//*****************************************************************************
// 全局配置
//*****************************************************************************
pub static GLOBAL_CONFIG: Lazy<RwLock<HashMap<TypeId, Arc<dyn Any + Send + Sync>>>> =
Lazy::new(|| RwLock::new(HashMap::new()));
pub async fn init_config<T: 'static + Any + Send + Sync>(config: T) {
let mut context = GLOBAL_CONFIG.write().await;
context.insert(TypeId::of::<T>(), Arc::new(config));
}
pub async fn get_config<T: 'static + Any + Send + Sync>() -> Option<Arc<T>> {
let context = GLOBAL_CONFIG.read().await;
context
.get(&TypeId::of::<T>())
.and_then(|config| config.clone().downcast::<T>().ok())
}
//*****************************************************************************
// 数据库连接
//*****************************************************************************
pub static GLOBAL_PRIMARY_DB: Lazy<RwLock<Option<Arc<DatabaseConnection>>>> =
Lazy::new(|| RwLock::new(None));
pub static GLOBAL_DB_POOL: Lazy<RwLock<HashMap<String, Arc<DatabaseConnection>>>> =
Lazy::new(|| RwLock::new(HashMap::new()));
// Redis连接
#[derive(Clone)]
pub enum RedisConnection {
Single(Arc<Client>),
Cluster(Arc<ClusterClient>),
}
pub static GLOBAL_PRIMARY_REDIS: Lazy<RwLock<Option<RedisConnection>>> =
Lazy::new(|| RwLock::new(None));
pub static GLOBAL_REDIS_POOL: Lazy<RwLock<HashMap<String, RedisConnection>>> =
Lazy::new(|| RwLock::new(HashMap::new()));
// MongoDB 连接
pub static GLOBAL_PRIMARY_MONGO: Lazy<RwLock<Option<Arc<MongoClient>>>> =
Lazy::new(|| RwLock::new(None));
pub static GLOBAL_MONGO_POOL: Lazy<RwLock<HashMap<String, Arc<MongoClient>>>> =
Lazy::new(|| RwLock::new(HashMap::new()));
//*****************************************************************************
// AWS S3 Clients
//*****************************************************************************
// 主要的 S3 客户端
pub static GLOBAL_PRIMARY_S3: Lazy<RwLock<Option<Arc<S3Client>>>> = Lazy::new(|| RwLock::new(None));
// 命名的 S3 客户端池
pub static GLOBAL_S3_POOL: Lazy<RwLock<HashMap<String, Arc<S3Client>>>> =
Lazy::new(|| RwLock::new(HashMap::new()));
//*****************************************************************************
// JWT 密钥和验证
//*****************************************************************************
pub struct Keys {
pub encoding: EncodingKey,
pub decoding: DecodingKey,
}
impl Keys {
pub fn new(secret: &[u8]) -> Self {
Self {
encoding: EncodingKey::from_secret(secret),
decoding: DecodingKey::from_secret(secret),
}
}
}
pub static KEYS: OnceCell<Arc<Mutex<Keys>>> = OnceCell::const_new();
pub static VALIDATION: OnceCell<Arc<Mutex<Validation>>> = OnceCell::const_new();
//*****************************************************************************
// 事件通道
//*****************************************************************************
/// 事件通道条目
struct DynChannelEntry {
name: String,
tx: mpsc::UnboundedSender<Box<dyn Any + Send>>,
}
/// 事件通道管理器
struct EventChannels {
string_tx: mpsc::UnboundedSender<String>,
dyn_channels: Vec<DynChannelEntry>,
}
static EVENT_CHANNELS: Lazy<Arc<Mutex<EventChannels>>> = Lazy::new(|| {
let (string_tx, _) = mpsc::unbounded_channel();
Arc::new(Mutex::new(EventChannels {
string_tx,
dyn_channels: Vec::new(),
}))
});
type DynFuture = dyn Future<Output = ()> + Send + 'static;
type StringListener = Box<dyn FnOnce(mpsc::UnboundedReceiver<String>) -> Pin<Box<DynFuture>>>;
type DynListener = (
String,
Box<dyn Fn(mpsc::UnboundedReceiver<Box<dyn Any + Send>>) -> Pin<Box<DynFuture>>>,
);
/// 获取字符串事件发送器
#[inline]
pub async fn get_string_sender() -> mpsc::UnboundedSender<String> {
EVENT_CHANNELS.lock().await.string_tx.clone()
}
/// 获取动态类型事件发送器
#[inline]
pub async fn get_dyn_sender(name: &str) -> Option<mpsc::UnboundedSender<Box<dyn Any + Send>>> {
let channels = EVENT_CHANNELS.lock().await;
channels
.dyn_channels
.iter()
.find(|entry| entry.name == name)
.map(|entry| entry.tx.clone())
}
/// 注册事件监听器
pub async fn register_event_listeners(
string_listener: StringListener,
dyn_listeners: &[DynListener],
) {
let mut channels = EVENT_CHANNELS.lock().await;
// 设置字符串事件通道
let (string_tx, string_rx) = mpsc::unbounded_channel();
channels.string_tx = string_tx;
// 启动字符串事件监听器
tokio::spawn(string_listener(string_rx));
project_info!("String event listener spawned");
// 清空旧的发送器
channels.dyn_channels.clear();
// 为每个监听器创建独立通道
for (name, listener) in dyn_listeners {
let (tx, rx) = mpsc::unbounded_channel();
channels.dyn_channels.push(DynChannelEntry {
name: name.clone(),
tx,
});
tokio::spawn(listener(rx));
project_info!("Dynamic event listener '{}' spawned", name);
}
}
//*****************************************************************************
// 路由信息收集
//*****************************************************************************
#[derive(Clone, Debug)]
pub struct RouteInfo {
pub path: String,
pub method: Method,
pub service_name: String,
pub summary: String,
}
impl RouteInfo {
pub fn new(path: &str, method: Method, service_name: &str, summary: &str) -> Self {
RouteInfo {
path: path.to_string(),
method,
service_name: service_name.to_string(),
summary: summary.to_string(),
}
}
}
pub static ROUTE_COLLECTOR: Lazy<Mutex<Vec<RouteInfo>>> = Lazy::new(|| Mutex::new(Vec::new()));
pub async fn add_route(route: RouteInfo) {
ROUTE_COLLECTOR.lock().await.push(route);
}
pub async fn get_collected_routes() -> Vec<RouteInfo> {
ROUTE_COLLECTOR.lock().await.clone()
}
pub async fn clear_routes() {
ROUTE_COLLECTOR.lock().await.clear();
}
//*****************************************************************************
// 操作日志
//*****************************************************************************
#[derive(Debug, Clone)]
pub struct OperationLogContext {
pub user_id: Option<String>,
pub username: Option<String>,
pub domain: Option<String>,
pub module_name: String,
pub description: String,
pub request_id: String,
pub method: String,
pub url: String,
pub ip: String,
pub user_agent: Option<String>,
pub params: Option<Value>,
pub body: Option<Value>,
pub response: Option<Value>,
pub start_time: NaiveDateTime,
pub end_time: NaiveDateTime,
pub duration: i32,
pub created_at: NaiveDateTime,
}
static OPERATION_LOG_CONTEXT: Lazy<Arc<RwLock<Option<OperationLogContext>>>> =
Lazy::new(|| Arc::new(RwLock::new(None)));
impl OperationLogContext {
pub async fn set(context: OperationLogContext) {
let mut writer = OPERATION_LOG_CONTEXT.write().await;
*writer = Some(context);
}
pub async fn get() -> Option<OperationLogContext> {
OPERATION_LOG_CONTEXT.read().await.clone()
}
pub async fn clear() {
let mut writer = OPERATION_LOG_CONTEXT.write().await;
*writer = None;
}
}
/// 异步发送字符串事件
#[inline]
pub fn send_string_event(msg: String) {
tokio::spawn(async move {
let sender = get_string_sender().await;
let _ = sender.send(msg);
});
}
/// 异步发送动态类型事件
#[inline]
pub fn send_dyn_event(event_name: &'static str, event: Box<dyn Any + Send>) {
tokio::spawn(async move {
if let Some(sender) = get_dyn_sender(event_name).await {
let _ = sender.send(event);
}
});
}
| rust | Apache-2.0 | a560191ee087ba509e2060f17937b9f2c8f9be33 | 2026-01-04T20:21:43.261270Z | false |
soybeanjs/soybean-admin-rust | https://github.com/soybeanjs/soybean-admin-rust/blob/a560191ee087ba509e2060f17937b9f2c8f9be33/server/global/src/lib.rs | server/global/src/lib.rs | pub use jsonwebtoken::Validation;
pub mod global;
#[macro_export]
macro_rules! project_info {
($($arg:tt)+) => {{
let span = tracing::span!(
tracing::Level::INFO,
module_path!(),
file = file!(),
line = line!(),
);
let _enter = span.enter();
tracing::info!(
target: "[soybean-admin-rust]",
$($arg)+
);
}}
}
#[macro_export]
macro_rules! project_error {
($($arg:tt)+) => {{
let span = tracing::span!(
tracing::Level::ERROR,
module_path!(),
file = file!(),
line = line!(),
);
let _enter = span.enter();
tracing::error!(
target: "[soybean-admin-rust]",
$($arg)+
);
}}
}
| rust | Apache-2.0 | a560191ee087ba509e2060f17937b9f2c8f9be33 | 2026-01-04T20:21:43.261270Z | false |
soybeanjs/soybean-admin-rust | https://github.com/soybeanjs/soybean-admin-rust/blob/a560191ee087ba509e2060f17937b9f2c8f9be33/server/resource/src/lib.rs | server/resource/src/lib.rs | use anyhow::Result;
use askama::Template;
use std::path::PathBuf;
#[allow(dead_code)]
mod filters {
#[allow(dead_code)]
pub fn lower(s: &str) -> ::askama::Result<String> {
Ok(s.to_lowercase())
}
#[allow(dead_code)]
pub fn title(s: &str) -> ::askama::Result<String> {
Ok(s.to_string())
}
}
#[derive(Template)]
#[template(path = "error.rs.askama", escape = "none")]
struct ErrorTemplate {
name: String,
}
impl ErrorTemplate {
fn lower(&self) -> String {
self.name.to_lowercase()
}
}
#[derive(Template)]
#[template(path = "input.rs.askama", escape = "none")]
struct InputTemplate {
name: String,
}
impl InputTemplate {
fn lower(&self) -> String {
self.name.to_lowercase()
}
}
#[derive(Template)]
#[template(path = "service.rs.askama", escape = "none")]
struct ServiceTemplate {
name: String,
}
impl ServiceTemplate {
fn lower(&self) -> String {
self.name.to_lowercase()
}
}
#[derive(Template)]
#[template(path = "api.rs.askama", escape = "none")]
struct ApiTemplate {
name: String,
}
impl ApiTemplate {
fn lower(&self) -> String {
self.name.to_lowercase()
}
fn title(&self) -> String {
self.name.to_string()
}
}
pub fn generate_code(name: &str, base_path: impl Into<PathBuf>) -> Result<()> {
let base_path = base_path.into();
let name = name.to_string();
let error_template = ErrorTemplate { name: name.clone() };
let error_code = error_template.render()?;
let error_path = base_path
.join("server")
.join("service")
.join("src")
.join("admin")
.join("errors")
.join(format!("sys_{}_error.rs", name.to_lowercase()));
std::fs::create_dir_all(error_path.parent().unwrap())?;
std::fs::write(error_path, error_code)?;
let input_template = InputTemplate { name: name.clone() };
let input_code = input_template.render()?;
let input_path = base_path
.join("server")
.join("model")
.join("src")
.join("admin")
.join("input")
.join(format!("sys_{}.rs", name.to_lowercase()));
std::fs::create_dir_all(input_path.parent().unwrap())?;
std::fs::write(input_path, input_code)?;
let service_template = ServiceTemplate { name: name.clone() };
let service_code = service_template.render()?;
let service_path = base_path
.join("server")
.join("service")
.join("src")
.join("admin")
.join(format!("sys_{}_service.rs", name.to_lowercase()));
std::fs::create_dir_all(service_path.parent().unwrap())?;
std::fs::write(service_path, service_code)?;
let api_template = ApiTemplate { name: name.clone() };
let api_code = api_template.render()?;
let api_path = base_path
.join("server")
.join("api")
.join("src")
.join("admin")
.join(format!("sys_{}_api.rs", name.to_lowercase()));
std::fs::create_dir_all(api_path.parent().unwrap())?;
std::fs::write(api_path, api_code)?;
Ok(())
}
#[cfg(test)]
mod tests {
use super::*;
use std::fs;
#[test]
fn test_code_generation() -> Result<()> {
let current_dir = std::env::current_dir()?;
println!("当前目录: {:?}", current_dir);
generate_code("Role", ¤t_dir)?;
let files_to_check = vec![
current_dir
.join("server")
.join("service")
.join("src")
.join("admin")
.join("errors")
.join("sys_role_error.rs"),
current_dir
.join("server")
.join("model")
.join("src")
.join("admin")
.join("input")
.join("sys_role.rs"),
current_dir
.join("server")
.join("service")
.join("src")
.join("admin")
.join("sys_role_service.rs"),
current_dir
.join("server")
.join("api")
.join("src")
.join("admin")
.join("sys_role_api.rs"),
];
println!("检查以下文件:");
for file in &files_to_check {
println!(" - {:?}", file);
}
for file in files_to_check {
if !file.exists() {
println!("文件不存在: {:?}", file);
assert!(file.exists(), "File {:?} should exist", file);
}
let content = fs::read_to_string(&file)?;
assert!(!content.is_empty(), "File {:?} should not be empty", file);
assert!(
content.contains("Role"),
"File {:?} should contain 'Role'",
file
);
if file.ends_with("sys_role_error.rs") {
assert!(content.contains("RoleError"));
assert!(content.contains("RoleNotFound"));
} else if file.ends_with("sys_role.rs") {
assert!(content.contains("RolePageRequest"));
assert!(content.contains("RoleInput"));
} else if file.ends_with("sys_role_service.rs") {
assert!(content.contains("RoleService"));
assert!(content.contains("TRoleService"));
} else if file.ends_with("sys_role_api.rs") {
assert!(content.contains("RoleApi"));
assert!(content.contains("get_role"));
}
}
Ok(())
}
}
| rust | Apache-2.0 | a560191ee087ba509e2060f17937b9f2c8f9be33 | 2026-01-04T20:21:43.261270Z | false |
soybeanjs/soybean-admin-rust | https://github.com/soybeanjs/soybean-admin-rust/blob/a560191ee087ba509e2060f17937b9f2c8f9be33/server/model/src/lib.rs | server/model/src/lib.rs | pub mod admin;
| rust | Apache-2.0 | a560191ee087ba509e2060f17937b9f2c8f9be33 | 2026-01-04T20:21:43.261270Z | false |
soybeanjs/soybean-admin-rust | https://github.com/soybeanjs/soybean-admin-rust/blob/a560191ee087ba509e2060f17937b9f2c8f9be33/server/model/src/admin/mod.rs | server/model/src/admin/mod.rs | pub mod input;
pub mod entities;
pub mod output;
| rust | Apache-2.0 | a560191ee087ba509e2060f17937b9f2c8f9be33 | 2026-01-04T20:21:43.261270Z | false |
soybeanjs/soybean-admin-rust | https://github.com/soybeanjs/soybean-admin-rust/blob/a560191ee087ba509e2060f17937b9f2c8f9be33/server/model/src/admin/entities/sys_access_key.rs | server/model/src/admin/entities/sys_access_key.rs | //! `SeaORM` Entity, @generated by sea-orm-codegen 1.0.0
use sea_orm::entity::prelude::*;
use serde::Serialize;
use super::sea_orm_active_enums::Status;
#[derive(Clone, Debug, PartialEq, DeriveEntityModel, Eq, Serialize)]
#[sea_orm(table_name = "sys_access_key")]
pub struct Model {
#[sea_orm(primary_key, auto_increment = false, column_type = "Text")]
pub id: String,
#[sea_orm(column_type = "Text")]
pub domain: String,
#[sea_orm(column_type = "Text", unique)]
pub access_key_id: String,
#[sea_orm(column_type = "Text", unique)]
pub access_key_secret: String,
pub status: Status,
#[sea_orm(column_type = "Text", nullable)]
pub description: Option<String>,
pub created_at: DateTime,
#[sea_orm(column_type = "Text")]
pub created_by: String,
}
#[derive(Copy, Clone, Debug, EnumIter, DeriveRelation)]
pub enum Relation {}
impl ActiveModelBehavior for ActiveModel {}
| rust | Apache-2.0 | a560191ee087ba509e2060f17937b9f2c8f9be33 | 2026-01-04T20:21:43.261270Z | false |
soybeanjs/soybean-admin-rust | https://github.com/soybeanjs/soybean-admin-rust/blob/a560191ee087ba509e2060f17937b9f2c8f9be33/server/model/src/admin/entities/prelude.rs | server/model/src/admin/entities/prelude.rs | //! `SeaORM` Entity, @generated by sea-orm-codegen 1.0.0
pub use super::{
casbin_rule::Entity as CasbinRule, sys_access_key::Entity as SysAccessKey,
sys_domain::Entity as SysDomain, sys_endpoint::Entity as SysEndpoint,
sys_login_log::Entity as SysLoginLog, sys_menu::Entity as SysMenu,
sys_operation_log::Entity as SysOperationLog, sys_organization::Entity as SysOrganization,
sys_role::Entity as SysRole, sys_role_menu::Entity as SysRoleMenu,
sys_tokens::Entity as SysTokens, sys_user::Entity as SysUser,
sys_user_role::Entity as SysUserRole,
};
| rust | Apache-2.0 | a560191ee087ba509e2060f17937b9f2c8f9be33 | 2026-01-04T20:21:43.261270Z | false |
soybeanjs/soybean-admin-rust | https://github.com/soybeanjs/soybean-admin-rust/blob/a560191ee087ba509e2060f17937b9f2c8f9be33/server/model/src/admin/entities/sys_operation_log.rs | server/model/src/admin/entities/sys_operation_log.rs | //! `SeaORM` Entity, @generated by sea-orm-codegen 1.0.0
use sea_orm::entity::prelude::*;
use serde::Serialize;
use serde_json::Value as JsonValue;
#[derive(Clone, Debug, PartialEq, DeriveEntityModel, Eq, Serialize)]
#[sea_orm(table_name = "sys_operation_log")]
#[serde(rename_all = "camelCase")]
pub struct Model {
#[sea_orm(primary_key, auto_increment = false, column_type = "Text")]
pub id: String,
#[sea_orm(column_type = "Text")]
pub user_id: String,
#[sea_orm(column_type = "Text")]
pub username: String,
#[sea_orm(column_type = "Text")]
pub domain: String,
#[sea_orm(column_type = "Text")]
pub module_name: String,
#[sea_orm(column_type = "Text")]
pub description: String,
#[sea_orm(column_type = "Text")]
pub request_id: String,
#[sea_orm(column_type = "Text")]
pub method: String,
#[sea_orm(column_type = "Text")]
pub url: String,
#[sea_orm(column_type = "Text")]
pub ip: String,
#[sea_orm(column_type = "Text", nullable)]
pub user_agent: Option<String>,
#[sea_orm(column_type = "JsonBinary", nullable)]
pub params: Option<JsonValue>,
#[sea_orm(column_type = "JsonBinary", nullable)]
pub body: Option<JsonValue>,
#[sea_orm(column_type = "JsonBinary", nullable)]
pub response: Option<JsonValue>,
pub start_time: DateTime,
pub end_time: DateTime,
pub duration: i32,
pub created_at: DateTime,
}
#[derive(Copy, Clone, Debug, EnumIter, DeriveRelation)]
pub enum Relation {}
impl ActiveModelBehavior for ActiveModel {}
| rust | Apache-2.0 | a560191ee087ba509e2060f17937b9f2c8f9be33 | 2026-01-04T20:21:43.261270Z | false |
soybeanjs/soybean-admin-rust | https://github.com/soybeanjs/soybean-admin-rust/blob/a560191ee087ba509e2060f17937b9f2c8f9be33/server/model/src/admin/entities/sea_orm_active_enums.rs | server/model/src/admin/entities/sea_orm_active_enums.rs | //! `SeaORM` Entity, @generated by sea-orm-codegen 1.0.0
use sea_orm::entity::prelude::*;
use serde::{Deserialize, Serialize};
#[derive(Debug, Clone, PartialEq, Eq, EnumIter, DeriveActiveEnum, Deserialize, Serialize)]
#[sea_orm(rs_type = "String", db_type = "Enum", enum_name = "menu_type")]
pub enum MenuType {
#[sea_orm(string_value = "directory")]
#[serde(rename = "directory")]
Directory,
#[sea_orm(string_value = "menu")]
#[serde(rename = "menu")]
Menu,
}
#[derive(Debug, Clone, PartialEq, Eq, EnumIter, DeriveActiveEnum, Deserialize, Serialize)]
// TIPS: pg大小写敏感会存在问题clear 因此项目最初作为soybean-admin-nestjs孪生项目所以枚举最初为大写 现在统一修正为小写
///PostgreSQL 对标识符（包括自定义类型名、表名、列名等）的命名有明确规则：未加双引号的标识符会自动折叠为小写 。因此，推荐始终使用小写字母和下划线（snake_case）来命名对象，就能避免大小写混淆或关键字冲突的问题。如 Bytebase 风格指南指出，“所有对象名称必须只使用小写字母、下划线和数字，名称必须遵循 snake_case” 。Pigsty 等社区规范也建议：表名、列名等一律小写，避免使用大写或驼峰等需要引用的形式  
#[sea_orm(rs_type = "String", db_type = "Enum", enum_name = "status")]
pub enum Status {
#[sea_orm(string_value = "banned")]
#[serde(rename = "banned")]
Banned,
#[sea_orm(string_value = "disabled")]
#[serde(rename = "disabled")]
Disabled,
#[sea_orm(string_value = "enabled")]
#[serde(rename = "enabled")]
Enabled,
}
| rust | Apache-2.0 | a560191ee087ba509e2060f17937b9f2c8f9be33 | 2026-01-04T20:21:43.261270Z | false |
soybeanjs/soybean-admin-rust | https://github.com/soybeanjs/soybean-admin-rust/blob/a560191ee087ba509e2060f17937b9f2c8f9be33/server/model/src/admin/entities/sys_user.rs | server/model/src/admin/entities/sys_user.rs | //! `SeaORM` Entity, @generated by sea-orm-codegen 1.1.0
use sea_orm::entity::prelude::*;
use serde::Serialize;
use super::sea_orm_active_enums::Status;
#[derive(Clone, Debug, PartialEq, DeriveEntityModel, Eq, Serialize)]
#[sea_orm(table_name = "sys_user")]
pub struct Model {
#[sea_orm(primary_key, auto_increment = false, column_type = "Text")]
pub id: String,
#[sea_orm(column_type = "Text", unique)]
pub username: String,
#[sea_orm(column_type = "Text")]
pub password: String,
#[sea_orm(column_type = "Text")]
pub domain: String,
pub built_in: bool,
#[sea_orm(column_type = "Text", nullable)]
pub avatar: Option<String>,
#[sea_orm(column_type = "Text", nullable, unique)]
pub email: Option<String>,
#[sea_orm(column_type = "Text", nullable, unique)]
pub phone_number: Option<String>,
#[sea_orm(column_type = "Text")]
pub nick_name: String,
pub status: Status,
pub created_at: DateTime,
#[sea_orm(column_type = "Text")]
pub created_by: String,
pub updated_at: Option<DateTime>,
#[sea_orm(column_type = "Text", nullable)]
pub updated_by: Option<String>,
}
#[derive(Copy, Clone, Debug, EnumIter, DeriveRelation)]
pub enum Relation {
#[sea_orm(
belongs_to = "super::sys_domain::Entity",
from = "Column::Domain",
to = "super::sys_domain::Column::Code"
)]
SysDomain,
#[sea_orm(has_many = "super::sys_user_role::Entity")]
SysUserRole,
}
impl Related<super::sys_domain::Entity> for Entity {
fn to() -> RelationDef {
Relation::SysDomain.def()
}
}
impl Related<super::sys_user_role::Entity> for Entity {
fn to() -> RelationDef {
Relation::SysUserRole.def()
}
}
impl ActiveModelBehavior for ActiveModel {}
| rust | Apache-2.0 | a560191ee087ba509e2060f17937b9f2c8f9be33 | 2026-01-04T20:21:43.261270Z | false |
soybeanjs/soybean-admin-rust | https://github.com/soybeanjs/soybean-admin-rust/blob/a560191ee087ba509e2060f17937b9f2c8f9be33/server/model/src/admin/entities/sys_role.rs | server/model/src/admin/entities/sys_role.rs | //! `SeaORM` Entity, @generated by sea-orm-codegen 1.1.0
use sea_orm::entity::prelude::*;
use serde::Serialize;
use super::sea_orm_active_enums::Status;
#[derive(Clone, Debug, PartialEq, DeriveEntityModel, Eq, Serialize)]
#[sea_orm(table_name = "sys_role")]
pub struct Model {
#[sea_orm(primary_key, auto_increment = false, column_type = "Text")]
pub id: String,
#[sea_orm(column_type = "Text", unique)]
pub code: String,
#[sea_orm(column_type = "Text")]
pub name: String,
#[sea_orm(column_type = "Text", nullable)]
pub description: Option<String>,
#[sea_orm(column_type = "Text")]
pub pid: String,
pub status: Status,
pub created_at: DateTime,
#[sea_orm(column_type = "Text")]
pub created_by: String,
pub updated_at: Option<DateTime>,
#[sea_orm(column_type = "Text", nullable)]
pub updated_by: Option<String>,
}
#[derive(Copy, Clone, Debug, EnumIter, DeriveRelation)]
pub enum Relation {
#[sea_orm(has_many = "super::sys_role_menu::Entity")]
SysRoleMenu,
#[sea_orm(has_many = "super::sys_user_role::Entity")]
SysUserRole,
}
impl Related<super::sys_role_menu::Entity> for Entity {
fn to() -> RelationDef {
Relation::SysRoleMenu.def()
}
}
impl Related<super::sys_user_role::Entity> for Entity {
fn to() -> RelationDef {
Relation::SysUserRole.def()
}
}
impl ActiveModelBehavior for ActiveModel {}
| rust | Apache-2.0 | a560191ee087ba509e2060f17937b9f2c8f9be33 | 2026-01-04T20:21:43.261270Z | false |
soybeanjs/soybean-admin-rust | https://github.com/soybeanjs/soybean-admin-rust/blob/a560191ee087ba509e2060f17937b9f2c8f9be33/server/model/src/admin/entities/sys_login_log.rs | server/model/src/admin/entities/sys_login_log.rs | //! `SeaORM` Entity, @generated by sea-orm-codegen 1.0.0
use sea_orm::entity::prelude::*;
use serde::Serialize;
#[derive(Clone, Debug, PartialEq, DeriveEntityModel, Eq, Serialize)]
#[sea_orm(table_name = "sys_login_log")]
#[serde(rename_all = "camelCase")]
pub struct Model {
#[sea_orm(primary_key, auto_increment = false, column_type = "Text")]
pub id: String,
#[sea_orm(column_type = "Text")]
pub user_id: String,
#[sea_orm(column_type = "Text")]
pub username: String,
#[sea_orm(column_type = "Text")]
pub domain: String,
pub login_time: DateTime,
#[sea_orm(column_type = "Text")]
pub ip: String,
pub port: Option<i32>,
#[sea_orm(column_type = "Text")]
pub address: String,
#[sea_orm(column_type = "Text")]
pub user_agent: String,
#[sea_orm(column_type = "Text")]
pub request_id: String,
#[sea_orm(column_type = "Text")]
pub r#type: String,
pub created_at: DateTime,
#[sea_orm(column_type = "Text")]
pub created_by: String,
}
#[derive(Copy, Clone, Debug, EnumIter, DeriveRelation)]
pub enum Relation {}
impl ActiveModelBehavior for ActiveModel {}
| rust | Apache-2.0 | a560191ee087ba509e2060f17937b9f2c8f9be33 | 2026-01-04T20:21:43.261270Z | false |
soybeanjs/soybean-admin-rust | https://github.com/soybeanjs/soybean-admin-rust/blob/a560191ee087ba509e2060f17937b9f2c8f9be33/server/model/src/admin/entities/sys_domain.rs | server/model/src/admin/entities/sys_domain.rs | //! `SeaORM` Entity, @generated by sea-orm-codegen 1.1.0
use sea_orm::entity::prelude::*;
use serde::Serialize;
use super::sea_orm_active_enums::Status;
#[derive(Clone, Debug, PartialEq, DeriveEntityModel, Eq, Serialize)]
#[sea_orm(table_name = "sys_domain")]
pub struct Model {
#[sea_orm(primary_key, auto_increment = false, column_type = "Text")]
pub id: String,
#[sea_orm(column_type = "Text", unique)]
pub code: String,
#[sea_orm(column_type = "Text")]
pub name: String,
#[sea_orm(column_type = "Text", nullable)]
pub description: Option<String>,
pub status: Status,
pub created_at: DateTime,
#[sea_orm(column_type = "Text")]
pub created_by: String,
pub updated_at: Option<DateTime>,
#[sea_orm(column_type = "Text", nullable)]
pub updated_by: Option<String>,
}
#[derive(Copy, Clone, Debug, EnumIter, DeriveRelation)]
pub enum Relation {}
impl ActiveModelBehavior for ActiveModel {}
| rust | Apache-2.0 | a560191ee087ba509e2060f17937b9f2c8f9be33 | 2026-01-04T20:21:43.261270Z | false |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.