107 lines
3.4 KiB
Rust
107 lines
3.4 KiB
Rust
use crate::state::instance_groups;
|
|
use crate::state::instances::{
|
|
ContentSet, Instance, InstanceLaunchOverrides, InstanceLink,
|
|
LoaderComponent,
|
|
adapters::sqlite::{instance_rows, loader_component_rows},
|
|
};
|
|
use serde::{Deserialize, Serialize};
|
|
use sqlx::SqlitePool;
|
|
|
|
#[derive(Clone, Debug, Serialize, Deserialize)]
|
|
pub struct InstanceMetadata {
|
|
pub instance: Instance,
|
|
pub applied_content_set: ContentSet,
|
|
pub link: InstanceLink,
|
|
pub groups: Vec<String>,
|
|
pub launch_overrides: InstanceLaunchOverrides,
|
|
#[serde(default)]
|
|
pub loader_components: Vec<LoaderComponent>,
|
|
#[serde(default)]
|
|
pub synced_options: crate::state::InstanceSyncedOptions,
|
|
}
|
|
|
|
pub(crate) async fn get_instance(
|
|
instance_id: &str,
|
|
pool: &SqlitePool,
|
|
) -> crate::Result<Option<InstanceMetadata>> {
|
|
get_instance_metadata(instance_id, pool).await
|
|
}
|
|
|
|
pub(crate) async fn get_instance_metadata(
|
|
instance_id: &str,
|
|
pool: &SqlitePool,
|
|
) -> crate::Result<Option<InstanceMetadata>> {
|
|
let Some(record) =
|
|
instance_rows::get_instance_metadata_by_id(instance_id, pool).await?
|
|
else {
|
|
return Ok(None);
|
|
};
|
|
let loader_components =
|
|
loader_component_rows::list_loader_components(instance_id, pool)
|
|
.await?;
|
|
let mut metadata = InstanceMetadata::from_record(record, loader_components);
|
|
metadata.synced_options =
|
|
instance_rows::get_instance_synced_options(instance_id, pool).await?;
|
|
Ok(Some(metadata))
|
|
}
|
|
|
|
pub(crate) async fn get_instances_metadata(
|
|
instance_ids: &[&str],
|
|
pool: &SqlitePool,
|
|
) -> crate::Result<Vec<InstanceMetadata>> {
|
|
let records =
|
|
instance_rows::get_instance_metadata_many(instance_ids, pool).await?;
|
|
let mut metadata = Vec::with_capacity(records.len());
|
|
for record in records {
|
|
let components = loader_component_rows::list_loader_components(
|
|
&record.instance.id,
|
|
pool,
|
|
)
|
|
.await?;
|
|
let mut item = InstanceMetadata::from_record(record, components);
|
|
item.synced_options =
|
|
instance_rows::get_instance_synced_options(&item.instance.id, pool)
|
|
.await?;
|
|
metadata.push(item);
|
|
}
|
|
Ok(metadata)
|
|
}
|
|
|
|
pub(crate) async fn list_instances(
|
|
pool: &SqlitePool,
|
|
) -> crate::Result<Vec<InstanceMetadata>> {
|
|
let records = instance_rows::list_instance_metadata(pool).await?;
|
|
let mut metadata = Vec::with_capacity(records.len());
|
|
for record in records {
|
|
let components = loader_component_rows::list_loader_components(
|
|
&record.instance.id,
|
|
pool,
|
|
)
|
|
.await?;
|
|
let mut item = InstanceMetadata::from_record(record, components);
|
|
item.synced_options =
|
|
instance_rows::get_instance_synced_options(&item.instance.id, pool)
|
|
.await?;
|
|
metadata.push(item);
|
|
}
|
|
Ok(metadata)
|
|
}
|
|
|
|
impl InstanceMetadata {
|
|
fn from_record(
|
|
record: instance_rows::InstanceMetadataRecord,
|
|
loader_components: Vec<LoaderComponent>,
|
|
) -> Self {
|
|
let groups = instance_groups::group_ids_for(&record.instance.id);
|
|
Self {
|
|
instance: record.instance,
|
|
applied_content_set: record.applied_content_set,
|
|
link: record.link,
|
|
groups,
|
|
launch_overrides: record.launch_overrides,
|
|
loader_components,
|
|
synced_options: Default::default(),
|
|
}
|
|
}
|
|
}
|