burncloud_database_models/
operations.rs1use crate::models::*;
2use crate::repository::*;
3use crate::converters::*;
4use burncloud_service_models as service;
5use sqlx::Pool;
6use uuid::Uuid;
7use async_trait::async_trait;
8
9pub struct PostgresOperations {
11 pub pool: Pool<sqlx::Postgres>,
12}
13
14impl PostgresOperations {
15 pub fn new(pool: Pool<sqlx::Postgres>) -> Self {
16 Self { pool }
17 }
18}
19
20#[async_trait]
21impl DatabaseRepository<sqlx::Postgres> for PostgresOperations {
22 type Error = RepositoryError;
23
24 async fn pool(&self) -> &Pool<sqlx::Postgres> {
25 &self.pool
26 }
27}
28
29#[async_trait]
30impl ModelRepository<sqlx::Postgres> for PostgresOperations {
31 async fn get_all_models(&self) -> Result<Vec<service::Model>, Self::Error> {
32 let models = Vec::new(); Ok(models)
35 }
36
37 async fn get_model_by_id(&self, _id: Uuid) -> Result<Option<service::Model>, Self::Error> {
38 Ok(None)
40 }
41
42 async fn get_model_by_name(&self, _name: &str) -> Result<Option<service::Model>, Self::Error> {
43 Ok(None)
45 }
46
47 async fn create_model(&self, _model: &service::Model) -> Result<(), Self::Error> {
48 Ok(())
50 }
51
52 async fn update_model(&self, _model: &service::Model) -> Result<(), Self::Error> {
53 Ok(())
55 }
56
57 async fn delete_model(&self, _id: Uuid) -> Result<(), Self::Error> {
58 Ok(())
60 }
61
62 async fn search_models(&self, _query: &str, _limit: Option<i64>) -> Result<Vec<service::Model>, Self::Error> {
63 Ok(Vec::new())
65 }
66
67 async fn get_models_by_type(&self, _model_type: &service::ModelType) -> Result<Vec<service::Model>, Self::Error> {
68 Ok(Vec::new())
70 }
71
72 async fn get_models_by_provider(&self, _provider: &str) -> Result<Vec<service::Model>, Self::Error> {
73 Ok(Vec::new())
75 }
76}
77
78#[async_trait]
79impl InstalledModelRepository<sqlx::Postgres> for PostgresOperations {
80 async fn get_all_installed_models(&self) -> Result<Vec<service::InstalledModel>, Self::Error> {
81 Ok(Vec::new())
83 }
84
85 async fn get_installed_model_by_model_id(&self, _model_id: Uuid) -> Result<Option<service::InstalledModel>, Self::Error> {
86 Ok(None)
88 }
89
90 async fn install_model(&self, _installed_model: &service::InstalledModel) -> Result<(), Self::Error> {
91 Ok(())
93 }
94
95 async fn update_installed_model(&self, _installed_model: &service::InstalledModel) -> Result<(), Self::Error> {
96 Ok(())
98 }
99
100 async fn uninstall_model(&self, _model_id: Uuid) -> Result<(), Self::Error> {
101 Ok(())
103 }
104
105 async fn get_installed_models_by_status(&self, _status: &service::ModelStatus) -> Result<Vec<service::InstalledModel>, Self::Error> {
106 Ok(Vec::new())
108 }
109
110 async fn update_model_usage(&self, _model_id: Uuid) -> Result<(), Self::Error> {
111 Ok(())
113 }
114}
115
116pub struct DatabaseOperationsFactory;
118
119impl DatabaseOperationsFactory {
120 #[cfg(feature = "postgres")]
122 pub fn create_postgres(pool: Pool<sqlx::Postgres>) -> PostgresOperations {
123 PostgresOperations::new(pool)
124 }
125}
126
127pub fn example_usage() {
129 let installed_model = service::InstalledModel {
131 model: service::Model::new(
132 "test-model".to_string(),
133 "Test Model".to_string(),
134 "1.0".to_string(),
135 service::ModelType::Chat,
136 "Test Provider".to_string(),
137 1024 * 1024 * 1024, ),
139 install_path: "/models/test".to_string(),
140 installed_at: chrono::Utc::now(),
141 status: service::ModelStatus::Stopped,
142 port: Some(8080),
143 process_id: None,
144 last_used: None,
145 usage_count: 0,
146 };
147
148 let (_db_model, _db_installed) = convert_installed_model_to_db(installed_model);
150}