pengjunjie/ragflow
1
0
Fork 1
mirror of https://github.com/infiniflow/ragflow.git synced 2026-01-04 03:25:30 +08:00
Code Issues Packages Projects Releases Wiki Activity

format code (#14)

Browse Source
This commit is contained in:
KevinHuSh
2023-12-25 10:17:13 +08:00
committed by GitHub
parent 8a65ad888e
commit 6858ec5f38
30 changed files with 1062 additions and 771 deletions
Download Patch File Download Diff File Expand all files Collapse all files

50
src/service/dialog_info.rs
View File

@ -1,19 +1,31 @@
use chrono::{Local, FixedOffset, Utc};
use chrono::{ Local, FixedOffset, Utc };
use migration::Expr;
use sea_orm::{ActiveModelTrait, DbConn, DbErr, DeleteResult, EntityTrait, PaginatorTrait, QueryOrder, UpdateResult};
use sea_orm::{
ActiveModelTrait,
DbConn,
DbErr,
DeleteResult,
EntityTrait,
PaginatorTrait,
QueryOrder,
UpdateResult,
};
use sea_orm::ActiveValue::Set;
use sea_orm::QueryFilter;
use sea_orm::ColumnTrait;
use crate::entity::dialog_info;
use crate::entity::dialog_info::Entity;
fn now()->chrono::DateTime<FixedOffset>{
Utc::now().with_timezone(&FixedOffset::east_opt(3600*8).unwrap())
fn now() -> chrono::DateTime<FixedOffset> {
Utc::now().with_timezone(&FixedOffset::east_opt(3600 * 8).unwrap())
}
pub struct Query;
impl Query {
pub async fn find_dialog_info_by_id(db: &DbConn, id: i64) -> Result<Option<dialog_info::Model>, DbErr> {
pub async fn find_dialog_info_by_id(
db: &DbConn,
id: i64
) -> Result<Option<dialog_info::Model>, DbErr> {
Entity::find_by_id(id).one(db).await
}
@ -21,18 +33,20 @@ impl Query {
Entity::find().all(db).await
}
pub async fn find_dialog_infos_by_uid(db: &DbConn, uid: i64) -> Result<Vec<dialog_info::Model>, DbErr> {
pub async fn find_dialog_infos_by_uid(
db: &DbConn,
uid: i64
) -> Result<Vec<dialog_info::Model>, DbErr> {
Entity::find()
.filter(dialog_info::Column::Uid.eq(uid))
.filter(dialog_info::Column::IsDeleted.eq(false))
.all(db)
.await
.all(db).await
}
pub async fn find_dialog_infos_in_page(
db: &DbConn,
page: u64,
posts_per_page: u64,
posts_per_page: u64
) -> Result<(Vec<dialog_info::Model>, u64), DbErr> {
// Setup paginator
let paginator = Entity::find()
@ -54,7 +68,7 @@ impl Mutation {
kb_id: i64,
name: &String
) -> Result<dialog_info::ActiveModel, DbErr> {
dialog_info::ActiveModel {
(dialog_info::ActiveModel {
dialog_id: Default::default(),
uid: Set(uid),
kb_id: Set(kb_id),
@ -62,16 +76,14 @@ impl Mutation {
history: Set("".to_owned()),
created_at: Set(now()),
updated_at: Set(now()),
is_deleted: Default::default()
}
.save(db)
.await
is_deleted: Default::default(),
}).save(db).await
}
pub async fn update_dialog_info_by_id(
db: &DbConn,
dialog_id: i64,
dialog_name:&String,
dialog_name: &String,
history: &String
) -> Result<UpdateResult, DbErr> {
Entity::update_many()
@ -79,19 +91,17 @@ impl Mutation {
.col_expr(dialog_info::Column::History, Expr::value(history))
.col_expr(dialog_info::Column::UpdatedAt, Expr::value(now()))
.filter(dialog_info::Column::DialogId.eq(dialog_id))
.exec(db)
.await
.exec(db).await
}
pub async fn delete_dialog_info(db: &DbConn, dialog_id: i64) -> Result<UpdateResult, DbErr> {
Entity::update_many()
.col_expr(dialog_info::Column::IsDeleted, Expr::value(true))
.filter(dialog_info::Column::DialogId.eq(dialog_id))
.exec(db)
.await
.exec(db).await
}
pub async fn delete_all_dialog_infos(db: &DbConn) -> Result<DeleteResult, DbErr> {
Entity::delete_many().exec(db).await
}
}
}

233
src/service/doc_info.rs
View File

@ -1,20 +1,41 @@
use chrono::{Utc, FixedOffset};
use sea_orm::{ActiveModelTrait, ColumnTrait, DbConn, DbErr, DeleteResult, EntityTrait, PaginatorTrait, QueryOrder, Unset, Unchanged, ConditionalStatement, QuerySelect, JoinType, RelationTrait, DbBackend, Statement, UpdateResult};
use chrono::{ Utc, FixedOffset };
use sea_orm::{
ActiveModelTrait,
ColumnTrait,
DbConn,
DbErr,
DeleteResult,
EntityTrait,
PaginatorTrait,
QueryOrder,
Unset,
Unchanged,
ConditionalStatement,
QuerySelect,
JoinType,
RelationTrait,
DbBackend,
Statement,
UpdateResult,
};
use sea_orm::ActiveValue::Set;
use sea_orm::QueryFilter;
use crate::api::doc_info::ListParams;
use crate::entity::{doc2_doc, doc_info};
use crate::entity::{ doc2_doc, doc_info };
use crate::entity::doc_info::Entity;
use crate::service;
fn now()->chrono::DateTime<FixedOffset>{
Utc::now().with_timezone(&FixedOffset::east_opt(3600*8).unwrap())
fn now() -> chrono::DateTime<FixedOffset> {
Utc::now().with_timezone(&FixedOffset::east_opt(3600 * 8).unwrap())
}
pub struct Query;
impl Query {
pub async fn find_doc_info_by_id(db: &DbConn, id: i64) -> Result<Option<doc_info::Model>, DbErr> {
pub async fn find_doc_info_by_id(
db: &DbConn,
id: i64
) -> Result<Option<doc_info::Model>, DbErr> {
Entity::find_by_id(id).one(db).await
}
@ -22,57 +43,71 @@ impl Query {
Entity::find().all(db).await
}
pub async fn find_doc_infos_by_uid(db: &DbConn, uid: i64) -> Result<Vec<doc_info::Model>, DbErr> {
Entity::find()
.filter(doc_info::Column::Uid.eq(uid))
.all(db)
.await
pub async fn find_doc_infos_by_uid(
db: &DbConn,
uid: i64
) -> Result<Vec<doc_info::Model>, DbErr> {
Entity::find().filter(doc_info::Column::Uid.eq(uid)).all(db).await
}
pub async fn find_doc_infos_by_name(db: &DbConn, uid: i64, name: &String, parent_id:Option<i64>) -> Result<Vec<doc_info::Model>, DbErr> {
pub async fn find_doc_infos_by_name(
db: &DbConn,
uid: i64,
name: &String,
parent_id: Option<i64>
) -> Result<Vec<doc_info::Model>, DbErr> {
let mut dids = Vec::<i64>::new();
if let Some(pid) = parent_id {
for d2d in doc2_doc::Entity::find().filter(doc2_doc::Column::ParentId.eq(pid)).all(db).await?{
for d2d in doc2_doc::Entity
::find()
.filter(doc2_doc::Column::ParentId.eq(pid))
.all(db).await? {
dids.push(d2d.did);
}
}
else{
} else {
let doc = Entity::find()
.filter(doc_info::Column::DocName.eq(name.clone()))
.filter(doc_info::Column::Uid.eq(uid))
.all(db)
.await?;
if doc.len() == 0{
.all(db).await?;
if doc.len() == 0 {
return Ok(vec![]);
}
assert!(doc.len()>0);
let d2d = doc2_doc::Entity::find().filter(doc2_doc::Column::Did.eq(doc[0].did)).all(db).await?;
assert!(doc.len() > 0);
let d2d = doc2_doc::Entity
::find()
.filter(doc2_doc::Column::Did.eq(doc[0].did))
.all(db).await?;
assert!(d2d.len() <= 1, "Did: {}->{}", doc[0].did, d2d.len());
if d2d.len()>0{
for d2d_ in doc2_doc::Entity::find().filter(doc2_doc::Column::ParentId.eq(d2d[0].parent_id)).all(db).await?{
if d2d.len() > 0 {
for d2d_ in doc2_doc::Entity
::find()
.filter(doc2_doc::Column::ParentId.eq(d2d[0].parent_id))
.all(db).await? {
dids.push(d2d_.did);
}
}
}
Entity::find()
.filter(doc_info::Column::DocName.eq(name.clone()))
.filter(doc_info::Column::Uid.eq(uid))
.filter(doc_info::Column::Did.is_in(dids))
.filter(doc_info::Column::IsDeleted.eq(false))
.all(db)
.await
.all(db).await
}
pub async fn all_descendent_ids(db: &DbConn, doc_ids: &Vec<i64>) -> Result<Vec<i64>, DbErr> {
let mut dids = doc_ids.clone();
let mut i:usize = 0;
let mut i: usize = 0;
loop {
if dids.len() == i {
break;
}
for d in doc2_doc::Entity::find().filter(doc2_doc::Column::ParentId.eq(dids[i])).all(db).await?{
for d in doc2_doc::Entity
::find()
.filter(doc2_doc::Column::ParentId.eq(dids[i]))
.all(db).await? {
dids.push(d.did);
}
i += 1;
@ -80,9 +115,13 @@ impl Query {
Ok(dids)
}
pub async fn find_doc_infos_by_params(db: &DbConn, params: ListParams) -> Result<Vec<doc_info::Model>, DbErr> {
pub async fn find_doc_infos_by_params(
db: &DbConn,
params: ListParams
) -> Result<Vec<doc_info::Model>, DbErr> {
// Setup paginator
let mut sql:String = "
let mut sql: String =
"
select
a.did,
a.uid,
@ -97,21 +136,33 @@ impl Query {
doc_info as a
".to_owned();
let mut cond:String = format!(" a.uid={} and a.is_deleted=False ", params.uid);
let mut cond: String = format!(" a.uid={} and a.is_deleted=False ", params.uid);
if let Some(kb_id) = params.filter.kb_id {
sql.push_str(&format!(" inner join kb2_doc on kb2_doc.did = a.did and kb2_doc.kb_id={}", kb_id));
sql.push_str(
&format!(" inner join kb2_doc on kb2_doc.did = a.did and kb2_doc.kb_id={}", kb_id)
);
}
if let Some(folder_id) = params.filter.folder_id {
sql.push_str(&format!(" inner join doc2_doc on a.did = doc2_doc.did and doc2_doc.parent_id={}", folder_id));
sql.push_str(
&format!(" inner join doc2_doc on a.did = doc2_doc.did and doc2_doc.parent_id={}", folder_id)
);
}
// Fetch paginated posts
if let Some(tag_id) = params.filter.tag_id {
let tag = service::tag_info::Query::find_tag_info_by_id(tag_id, &db).await.unwrap().unwrap();
if tag.folder_id > 0{
sql.push_str(&format!(" inner join doc2_doc on a.did = doc2_doc.did and doc2_doc.parent_id={}", tag.folder_id));
let tag = service::tag_info::Query
::find_tag_info_by_id(tag_id, &db).await
.unwrap()
.unwrap();
if tag.folder_id > 0 {
sql.push_str(
&format!(
" inner join doc2_doc on a.did = doc2_doc.did and doc2_doc.parent_id={}",
tag.folder_id
)
);
}
if tag.regx.len()>0{
if tag.regx.len() > 0 {
cond.push_str(&format!(" and doc_name ~ '{}'", tag.regx));
}
}
@ -119,7 +170,7 @@ impl Query {
if let Some(keywords) = params.filter.keywords {
cond.push_str(&format!(" and doc_name like '%{}%'", keywords));
}
if cond.len() > 0{
if cond.len() > 0 {
sql.push_str(&" where ");
sql.push_str(&cond);
}
@ -128,28 +179,26 @@ impl Query {
orderby = "updated_at desc".to_owned();
}
sql.push_str(&format!(" order by {}", orderby));
let mut page_size:u32 = 30;
let mut page_size: u32 = 30;
if let Some(pg_sz) = params.per_page {
page_size = pg_sz;
}
let mut page:u32 = 0;
let mut page: u32 = 0;
if let Some(pg) = params.page {
page = pg;
}
sql.push_str(&format!(" limit {} offset {} ;", page_size, page*page_size));
sql.push_str(&format!(" limit {} offset {} ;", page_size, page * page_size));
print!("{}", sql);
Entity::find()
.from_raw_sql(
Statement::from_sql_and_values(DbBackend::Postgres,sql,vec![])
).all(db).await
.from_raw_sql(Statement::from_sql_and_values(DbBackend::Postgres, sql, vec![]))
.all(db).await
}
pub async fn find_doc_infos_in_page(
db: &DbConn,
page: u64,
posts_per_page: u64,
posts_per_page: u64
) -> Result<(Vec<doc_info::Model>, u64), DbErr> {
// Setup paginator
let paginator = Entity::find()
@ -165,22 +214,18 @@ impl Query {
pub struct Mutation;
impl Mutation {
pub async fn mv_doc_info(
db: &DbConn,
dest_did: i64,
dids: &[i64]
) -> Result<(), DbErr> {
pub async fn mv_doc_info(db: &DbConn, dest_did: i64, dids: &[i64]) -> Result<(), DbErr> {
for did in dids {
let d = doc2_doc::Entity::find().filter(doc2_doc::Column::Did.eq(did.to_owned())).all(db).await?;
let _ = doc2_doc::ActiveModel {
let d = doc2_doc::Entity
::find()
.filter(doc2_doc::Column::Did.eq(did.to_owned()))
.all(db).await?;
let _ = (doc2_doc::ActiveModel {
id: Set(d[0].id),
did: Set(did.to_owned()),
parent_id: Set(dest_did)
}
.update(db)
.await?;
parent_id: Set(dest_did),
}).update(db).await?;
}
Ok(())
@ -190,21 +235,19 @@ impl Mutation {
db: &DbConn,
dest_did: i64,
did: i64
) -> Result<doc2_doc::ActiveModel, DbErr> {
doc2_doc::ActiveModel {
) -> Result<doc2_doc::ActiveModel, DbErr> {
(doc2_doc::ActiveModel {
id: Default::default(),
parent_id: Set(dest_did),
did: Set(did),
}
.save(db)
.await
}).save(db).await
}
pub async fn create_doc_info(
db: &DbConn,
form_data: doc_info::Model,
form_data: doc_info::Model
) -> Result<doc_info::ActiveModel, DbErr> {
doc_info::ActiveModel {
(doc_info::ActiveModel {
did: Default::default(),
uid: Set(form_data.uid.to_owned()),
doc_name: Set(form_data.doc_name.to_owned()),
@ -213,24 +256,21 @@ impl Mutation {
location: Set(form_data.location.to_owned()),
created_at: Set(form_data.created_at.to_owned()),
updated_at: Set(form_data.updated_at.to_owned()),
is_deleted:Default::default()
}
.save(db)
.await
is_deleted: Default::default(),
}).save(db).await
}
pub async fn update_doc_info_by_id(
db: &DbConn,
id: i64,
form_data: doc_info::Model,
form_data: doc_info::Model
) -> Result<doc_info::Model, DbErr> {
let doc_info: doc_info::ActiveModel = Entity::find_by_id(id)
.one(db)
.await?
.one(db).await?
.ok_or(DbErr::Custom("Cannot find.".to_owned()))
.map(Into::into)?;
doc_info::ActiveModel {
(doc_info::ActiveModel {
did: doc_info.did,
uid: Set(form_data.uid.to_owned()),
doc_name: Set(form_data.doc_name.to_owned()),
@ -240,46 +280,51 @@ impl Mutation {
created_at: doc_info.created_at,
updated_at: Set(now()),
is_deleted: Default::default(),
}
.update(db)
.await
}).update(db).await
}
pub async fn delete_doc_info(db: &DbConn, doc_ids: &Vec<i64>) -> Result<UpdateResult, DbErr> {
let mut dids = doc_ids.clone();
let mut i:usize = 0;
let mut i: usize = 0;
loop {
if dids.len() == i {
break;
}
let mut doc: doc_info::ActiveModel = Entity::find_by_id(dids[i])
.one(db)
.await?
.ok_or(DbErr::Custom(format!("Can't find doc:{}", dids[i])))
.map(Into::into)?;
doc.updated_at = Set(now());
.one(db).await?
.ok_or(DbErr::Custom(format!("Can't find doc:{}", dids[i])))
.map(Into::into)?;
doc.updated_at = Set(now());
doc.is_deleted = Set(true);
let _ = doc.update(db).await?;
for d in doc2_doc::Entity::find().filter(doc2_doc::Column::ParentId.eq(dids[i])).all(db).await?{
for d in doc2_doc::Entity
::find()
.filter(doc2_doc::Column::ParentId.eq(dids[i]))
.all(db).await? {
dids.push(d.did);
}
let _ = doc2_doc::Entity::delete_many().filter(doc2_doc::Column::ParentId.eq(dids[i])).exec(db).await?;
let _ = doc2_doc::Entity::delete_many().filter(doc2_doc::Column::Did.eq(dids[i])).exec(db).await?;
let _ = doc2_doc::Entity
::delete_many()
.filter(doc2_doc::Column::ParentId.eq(dids[i]))
.exec(db).await?;
let _ = doc2_doc::Entity
::delete_many()
.filter(doc2_doc::Column::Did.eq(dids[i]))
.exec(db).await?;
i += 1;
}
crate::service::kb_info::Mutation::remove_docs(&db, dids,None).await
crate::service::kb_info::Mutation::remove_docs(&db, dids, None).await
}
pub async fn rename(db: &DbConn, doc_id: i64, name: &String) -> Result<doc_info::Model, DbErr> {
let mut doc: doc_info::ActiveModel = Entity::find_by_id(doc_id)
.one(db)
.await?
.one(db).await?
.ok_or(DbErr::Custom(format!("Can't find doc:{}", doc_id)))
.map(Into::into)?;
doc.updated_at = Set(now());
doc.doc_name = Set(name.clone());
doc.update(db).await
doc.updated_at = Set(now());
doc.doc_name = Set(name.clone());
doc.update(db).await
}
pub async fn delete_all_doc_infos(db: &DbConn) -> Result<DeleteResult, DbErr> {

117
src/service/kb_info.rs
View File

@ -1,13 +1,24 @@
use chrono::{Local, FixedOffset, Utc};
use chrono::{ Local, FixedOffset, Utc };
use migration::Expr;
use sea_orm::{ActiveModelTrait, ColumnTrait, DbConn, DbErr, DeleteResult, EntityTrait, PaginatorTrait, QueryFilter, QueryOrder, UpdateResult};
use sea_orm::{
ActiveModelTrait,
ColumnTrait,
DbConn,
DbErr,
DeleteResult,
EntityTrait,
PaginatorTrait,
QueryFilter,
QueryOrder,
UpdateResult,
};
use sea_orm::ActiveValue::Set;
use crate::entity::kb_info;
use crate::entity::kb2_doc;
use crate::entity::kb_info::Entity;
fn now()->chrono::DateTime<FixedOffset>{
Utc::now().with_timezone(&FixedOffset::east_opt(3600*8).unwrap())
fn now() -> chrono::DateTime<FixedOffset> {
Utc::now().with_timezone(&FixedOffset::east_opt(3600 * 8).unwrap())
}
pub struct Query;
@ -21,22 +32,25 @@ impl Query {
}
pub async fn find_kb_infos_by_uid(db: &DbConn, uid: i64) -> Result<Vec<kb_info::Model>, DbErr> {
Entity::find()
.filter(kb_info::Column::Uid.eq(uid))
.all(db)
.await
}
pub async fn find_kb_infos_by_name(db: &DbConn, name: String) -> Result<Vec<kb_info::Model>, DbErr> {
Entity::find()
.filter(kb_info::Column::KbName.eq(name))
.all(db)
.await
Entity::find().filter(kb_info::Column::Uid.eq(uid)).all(db).await
}
pub async fn find_kb_by_docs(db: &DbConn, doc_ids: Vec<i64>) -> Result<Vec<kb_info::Model>, DbErr> {
pub async fn find_kb_infos_by_name(
db: &DbConn,
name: String
) -> Result<Vec<kb_info::Model>, DbErr> {
Entity::find().filter(kb_info::Column::KbName.eq(name)).all(db).await
}
pub async fn find_kb_by_docs(
db: &DbConn,
doc_ids: Vec<i64>
) -> Result<Vec<kb_info::Model>, DbErr> {
let mut kbids = Vec::<i64>::new();
for k in kb2_doc::Entity::find().filter(kb2_doc::Column::Did.is_in(doc_ids)).all(db).await?{
for k in kb2_doc::Entity
::find()
.filter(kb2_doc::Column::Did.is_in(doc_ids))
.all(db).await? {
kbids.push(k.kb_id);
}
Entity::find().filter(kb_info::Column::KbId.is_in(kbids)).all(db).await
@ -45,7 +59,7 @@ impl Query {
pub async fn find_kb_infos_in_page(
db: &DbConn,
page: u64,
posts_per_page: u64,
posts_per_page: u64
) -> Result<(Vec<kb_info::Model>, u64), DbErr> {
// Setup paginator
let paginator = Entity::find()
@ -63,44 +77,38 @@ pub struct Mutation;
impl Mutation {
pub async fn create_kb_info(
db: &DbConn,
form_data: kb_info::Model,
form_data: kb_info::Model
) -> Result<kb_info::ActiveModel, DbErr> {
kb_info::ActiveModel {
(kb_info::ActiveModel {
kb_id: Default::default(),
uid: Set(form_data.uid.to_owned()),
kb_name: Set(form_data.kb_name.to_owned()),
icon: Set(form_data.icon.to_owned()),
created_at: Set(now()),
updated_at: Set(now()),
is_deleted:Default::default()
}
.save(db)
.await
is_deleted: Default::default(),
}).save(db).await
}
pub async fn add_docs(
db: &DbConn,
kb_id: i64,
doc_ids: Vec<i64>
)-> Result<(), DbErr> {
for did in doc_ids{
let res = kb2_doc::Entity::find()
pub async fn add_docs(db: &DbConn, kb_id: i64, doc_ids: Vec<i64>) -> Result<(), DbErr> {
for did in doc_ids {
let res = kb2_doc::Entity
::find()
.filter(kb2_doc::Column::KbId.eq(kb_id))
.filter(kb2_doc::Column::Did.eq(did))
.all(db)
.await?;
if res.len()>0{continue;}
let _ = kb2_doc::ActiveModel {
.all(db).await?;
if res.len() > 0 {
continue;
}
let _ = (kb2_doc::ActiveModel {
id: Default::default(),
kb_id: Set(kb_id),
did: Set(did),
kb_progress: Set(0.0),
kb_progress_msg: Set("".to_owned()),
updated_at: Set(now()),
is_deleted:Default::default()
}
.save(db)
.await?;
is_deleted: Default::default(),
}).save(db).await?;
}
Ok(())
@ -110,17 +118,16 @@ impl Mutation {
db: &DbConn,
doc_ids: Vec<i64>,
kb_id: Option<i64>
)-> Result<UpdateResult, DbErr> {
let update = kb2_doc::Entity::update_many()
) -> Result<UpdateResult, DbErr> {
let update = kb2_doc::Entity
::update_many()
.col_expr(kb2_doc::Column::IsDeleted, Expr::value(true))
.col_expr(kb2_doc::Column::KbProgress, Expr::value(0))
.col_expr(kb2_doc::Column::KbProgressMsg, Expr::value(""))
.filter(kb2_doc::Column::Did.is_in(doc_ids));
if let Some(kbid) = kb_id{
update.filter(kb2_doc::Column::KbId.eq(kbid))
.exec(db)
.await
}else{
if let Some(kbid) = kb_id {
update.filter(kb2_doc::Column::KbId.eq(kbid)).exec(db).await
} else {
update.exec(db).await
}
}
@ -128,35 +135,31 @@ impl Mutation {
pub async fn update_kb_info_by_id(
db: &DbConn,
id: i64,
form_data: kb_info::Model,
form_data: kb_info::Model
) -> Result<kb_info::Model, DbErr> {
let kb_info: kb_info::ActiveModel = Entity::find_by_id(id)
.one(db)
.await?
.one(db).await?
.ok_or(DbErr::Custom("Cannot find.".to_owned()))
.map(Into::into)?;
kb_info::ActiveModel {
(kb_info::ActiveModel {
kb_id: kb_info.kb_id,
uid: kb_info.uid,
kb_name: Set(form_data.kb_name.to_owned()),
icon: Set(form_data.icon.to_owned()),
created_at: kb_info.created_at,
updated_at: Set(now()),
is_deleted: Default::default()
}
.update(db)
.await
is_deleted: Default::default(),
}).update(db).await
}
pub async fn delete_kb_info(db: &DbConn, kb_id: i64) -> Result<DeleteResult, DbErr> {
let kb: kb_info::ActiveModel = Entity::find_by_id(kb_id)
.one(db)
.await?
.one(db).await?
.ok_or(DbErr::Custom("Cannot find.".to_owned()))
.map(Into::into)?;
kb.delete(db).await
kb.delete(db).await
}
pub async fn delete_all_kb_infos(db: &DbConn) -> Result<DeleteResult, DbErr> {

2
src/service/mod.rs
View File

@ -2,4 +2,4 @@ pub(crate) mod dialog_info;
pub(crate) mod tag_info;
pub(crate) mod kb_info;
pub(crate) mod doc_info;
pub(crate) mod user_info;
pub(crate) mod user_info;

60
src/service/tag_info.rs
View File

@ -1,30 +1,40 @@
use chrono::{FixedOffset, Utc};
use sea_orm::{ActiveModelTrait, DbConn, DbErr, DeleteResult, EntityTrait, PaginatorTrait, QueryOrder, ColumnTrait, QueryFilter};
use sea_orm::ActiveValue::{Set, NotSet};
use chrono::{ FixedOffset, Utc };
use sea_orm::{
ActiveModelTrait,
DbConn,
DbErr,
DeleteResult,
EntityTrait,
PaginatorTrait,
QueryOrder,
ColumnTrait,
QueryFilter,
};
use sea_orm::ActiveValue::{ Set, NotSet };
use crate::entity::tag_info;
use crate::entity::tag_info::Entity;
fn now()->chrono::DateTime<FixedOffset>{
Utc::now().with_timezone(&FixedOffset::east_opt(3600*8).unwrap())
fn now() -> chrono::DateTime<FixedOffset> {
Utc::now().with_timezone(&FixedOffset::east_opt(3600 * 8).unwrap())
}
pub struct Query;
impl Query {
pub async fn find_tag_info_by_id(id: i64, db: &DbConn) -> Result<Option<tag_info::Model>, DbErr> {
pub async fn find_tag_info_by_id(
id: i64,
db: &DbConn
) -> Result<Option<tag_info::Model>, DbErr> {
Entity::find_by_id(id).one(db).await
}
pub async fn find_tags_by_uid(uid:i64, db: &DbConn) -> Result<Vec<tag_info::Model>, DbErr> {
Entity::find()
.filter(tag_info::Column::Uid.eq(uid))
.all(db)
.await
pub async fn find_tags_by_uid(uid: i64, db: &DbConn) -> Result<Vec<tag_info::Model>, DbErr> {
Entity::find().filter(tag_info::Column::Uid.eq(uid)).all(db).await
}
pub async fn find_tag_infos_in_page(
db: &DbConn,
page: u64,
posts_per_page: u64,
posts_per_page: u64
) -> Result<(Vec<tag_info::Model>, u64), DbErr> {
// Setup paginator
let paginator = Entity::find()
@ -42,9 +52,9 @@ pub struct Mutation;
impl Mutation {
pub async fn create_tag(
db: &DbConn,
form_data: tag_info::Model,
form_data: tag_info::Model
) -> Result<tag_info::ActiveModel, DbErr> {
tag_info::ActiveModel {
(tag_info::ActiveModel {
tid: Default::default(),
uid: Set(form_data.uid.to_owned()),
tag_name: Set(form_data.tag_name.to_owned()),
@ -53,27 +63,24 @@ impl Mutation {
icon: Set(form_data.icon.to_owned()),
folder_id: match form_data.folder_id {
0 => NotSet,
_ => Set(form_data.folder_id.to_owned())
_ => Set(form_data.folder_id.to_owned()),
},
created_at: Set(now()),
updated_at: Set(now()),
}
.save(db)
.await
}).save(db).await
}
pub async fn update_tag_by_id(
db: &DbConn,
id: i64,
form_data: tag_info::Model,
form_data: tag_info::Model
) -> Result<tag_info::Model, DbErr> {
let tag: tag_info::ActiveModel = Entity::find_by_id(id)
.one(db)
.await?
.one(db).await?
.ok_or(DbErr::Custom("Cannot find tag.".to_owned()))
.map(Into::into)?;
tag_info::ActiveModel {
(tag_info::ActiveModel {
tid: tag.tid,
uid: tag.uid,
tag_name: Set(form_data.tag_name.to_owned()),
@ -83,15 +90,12 @@ impl Mutation {
folder_id: Set(form_data.folder_id.to_owned()),
created_at: Default::default(),
updated_at: Set(now()),
}
.update(db)
.await
}).update(db).await
}
pub async fn delete_tag(db: &DbConn, tid: i64) -> Result<DeleteResult, DbErr> {
let tag: tag_info::ActiveModel = Entity::find_by_id(tid)
.one(db)
.await?
.one(db).await?
.ok_or(DbErr::Custom("Cannot find tag.".to_owned()))
.map(Into::into)?;
@ -101,4 +105,4 @@ impl Mutation {
pub async fn delete_all_tags(db: &DbConn) -> Result<DeleteResult, DbErr> {
Entity::delete_many().exec(db).await
}
}
}

81
src/service/user_info.rs
View File

@ -1,39 +1,56 @@
use chrono::{FixedOffset, Utc};
use chrono::{ FixedOffset, Utc };
use migration::Expr;
use sea_orm::{ActiveModelTrait, ColumnTrait, DbConn, DbErr, DeleteResult, EntityTrait, PaginatorTrait, QueryFilter, QueryOrder, UpdateResult};
use sea_orm::{
ActiveModelTrait,
ColumnTrait,
DbConn,
DbErr,
DeleteResult,
EntityTrait,
PaginatorTrait,
QueryFilter,
QueryOrder,
UpdateResult,
};
use sea_orm::ActiveValue::Set;
use crate::entity::user_info;
use crate::entity::user_info::Entity;
fn now()->chrono::DateTime<FixedOffset>{
Utc::now().with_timezone(&FixedOffset::east_opt(3600*8).unwrap())
fn now() -> chrono::DateTime<FixedOffset> {
Utc::now().with_timezone(&FixedOffset::east_opt(3600 * 8).unwrap())
}
pub struct Query;
impl Query {
pub async fn find_user_info_by_id(db: &DbConn, id: i64) -> Result<Option<user_info::Model>, DbErr> {
pub async fn find_user_info_by_id(
db: &DbConn,
id: i64
) -> Result<Option<user_info::Model>, DbErr> {
Entity::find_by_id(id).one(db).await
}
pub async fn login(db: &DbConn, email: &str, password: &str) -> Result<Option<user_info::Model>, DbErr> {
pub async fn login(
db: &DbConn,
email: &str,
password: &str
) -> Result<Option<user_info::Model>, DbErr> {
Entity::find()
.filter(user_info::Column::Email.eq(email))
.filter(user_info::Column::Password.eq(password))
.one(db)
.await
.one(db).await
}
pub async fn find_user_infos(db: &DbConn, email:&String) -> Result<Option<user_info::Model>, DbErr> {
Entity::find()
.filter(user_info::Column::Email.eq(email))
.one(db)
.await
pub async fn find_user_infos(
db: &DbConn,
email: &String
) -> Result<Option<user_info::Model>, DbErr> {
Entity::find().filter(user_info::Column::Email.eq(email)).one(db).await
}
pub async fn find_user_infos_in_page(
db: &DbConn,
page: u64,
posts_per_page: u64,
posts_per_page: u64
) -> Result<(Vec<user_info::Model>, u64), DbErr> {
// Setup paginator
let paginator = Entity::find()
@ -51,9 +68,9 @@ pub struct Mutation;
impl Mutation {
pub async fn create_user(
db: &DbConn,
form_data: &user_info::Model,
form_data: &user_info::Model
) -> Result<user_info::ActiveModel, DbErr> {
user_info::ActiveModel {
(user_info::ActiveModel {
uid: Default::default(),
email: Set(form_data.email.to_owned()),
nickname: Set(form_data.nickname.to_owned()),
@ -65,22 +82,19 @@ impl Mutation {
last_login_at: Set(now()),
created_at: Set(now()),
updated_at: Set(now()),
}
.save(db)
.await
}).save(db).await
}
pub async fn update_user_by_id(
db: &DbConn,
form_data: &user_info::Model,
form_data: &user_info::Model
) -> Result<user_info::Model, DbErr> {
let usr: user_info::ActiveModel = Entity::find_by_id(form_data.uid)
.one(db)
.await?
.one(db).await?
.ok_or(DbErr::Custom("Cannot find user.".to_owned()))
.map(Into::into)?;
user_info::ActiveModel {
(user_info::ActiveModel {
uid: Set(form_data.uid),
email: Set(form_data.email.to_owned()),
nickname: Set(form_data.nickname.to_owned()),
@ -91,27 +105,20 @@ impl Mutation {
password: Set(form_data.password.to_owned()),
updated_at: Set(now()),
last_login_at: usr.last_login_at,
created_at:usr.created_at,
}
.update(db)
.await
created_at: usr.created_at,
}).update(db).await
}
pub async fn update_login_status(
uid: i64,
db: &DbConn
) -> Result<UpdateResult, DbErr> {
pub async fn update_login_status(uid: i64, db: &DbConn) -> Result<UpdateResult, DbErr> {
Entity::update_many()
.col_expr(user_info::Column::LastLoginAt, Expr::value(now()))
.col_expr(user_info::Column::LastLoginAt, Expr::value(now()))
.filter(user_info::Column::Uid.eq(uid))
.exec(db)
.await
.exec(db).await
}
pub async fn delete_user(db: &DbConn, tid: i64) -> Result<DeleteResult, DbErr> {
let tag: user_info::ActiveModel = Entity::find_by_id(tid)
.one(db)
.await?
.one(db).await?
.ok_or(DbErr::Custom("Cannot find tag.".to_owned()))
.map(Into::into)?;
@ -121,4 +128,4 @@ impl Mutation {
pub async fn delete_all(db: &DbConn) -> Result<DeleteResult, DbErr> {
Entity::delete_many().exec(db).await
}
}
}