MightyPork
/
yopa
1
0
Fork 0
Code Issues Pull Requests Releases Wiki Activity

fix warning and reformat all

Browse Source
master
Ondřej Hruška 4 years ago
parent 6229f7969c
commit 2a93800765
Signed by: MightyPork
GPG Key ID: 2C5FD5035250423D
19 changed files with 1111 additions and 620 deletions
Show all changes Ignore whitespace when comparing lines Ignore changes in amount of whitespace Ignore changes in whitespace at EOL
Show Stats Download Patch File Download Diff File
  1. 3
      yopa-web/build.rs
  2. 322
      yopa-web/src/main.rs
  3. 25
      yopa-web/src/routes.rs
  4. 61
      yopa-web/src/routes/models.rs
  5. 19
      yopa-web/src/routes/models/object.rs
  6. 76
      yopa-web/src/routes/models/property.rs
  7. 45
      yopa-web/src/routes/models/relation.rs
  8. 226
      yopa-web/src/routes/objects.rs
  9. 41
      yopa-web/src/tera_ext.rs
  10. 29
      yopa-web/src/utils.rs
  11. 5
      yopa/src/cool.rs
  12. 297
      yopa/src/data.rs
  13. 6
      yopa/src/id.rs
  14. 10
      yopa/src/insert.rs
  15. 528
      yopa/src/lib.rs
  16. 2
      yopa/src/model.rs
  17. 26
      yopa/src/serde_map_as_list.rs
  18. 2
      yopa/src/tests.rs
  19. 8
      yopa/src/update.rs

3
yopa-web/build.rs
Unescape View File

@ -10,5 +10,6 @@ fn main() {
resource_dir("./resources/static")
.with_generated_filename(out_path.join("static_files.rs"))
.with_generated_fn("included_static_files")
.build().unwrap();
.build()
.unwrap();
}

322
yopa-web/src/main.rs
Unescape View File

@ -3,35 +3,27 @@ extern crate actix_web;
#[macro_use]
extern crate log;
use std::borrow::Borrow;
use std::collections::HashMap;
use std::ops::Deref;
use std::path::{Path, PathBuf};
use std::sync::Arc;
use std::sync::atomic::{AtomicUsize, Ordering};
use actix_session::CookieSession;
use actix_web::{App, get, HttpRequest, HttpResponse, HttpServer, post, Responder, web};
use actix_web::http::StatusCode;
use actix_web::web::{scope, service};
use actix_web::{web, App, HttpResponse, HttpServer};
use actix_web_static_files;
use actix_web_static_files::ResourceFiles as StaticFiles;
use include_dir::Dir;
use log::LevelFilter;
use once_cell::sync::Lazy;
use parking_lot::Mutex;
use rand::Rng;
use tera::Tera;
use yopa::insert::{InsertObj, InsertRel, InsertValue};
use yopa::{Storage, TypedValue};
use crate::tera_ext::TeraExt;
use yopa::insert::{InsertObj, InsertValue, InsertRel};
mod utils;
mod tera_ext;
mod routes;
mod session_ext;
mod tera_ext;
mod utils;
// Embed static files
include!(concat!(env!("OUT_DIR"), "/static_files.rs"));
@ -45,47 +37,52 @@ pub(crate) static TERA: Lazy<Tera> = Lazy::new(|| {
// Special filter for the TypedValue map
use serde_json::Value;
tera.register_filter("print_typed_value", |v: &Value, _: &HashMap<String, Value>| -> tera::Result<Value> {
if v.is_null() {
return Ok(v.clone());
}
if let Value::Object(map) = v {
if let Some((_, v)) = map.iter().next() {
tera.register_filter(
"print_typed_value",
|v: &Value, _: &HashMap<String, Value>| -> tera::Result<Value> {
if v.is_null() {
return Ok(v.clone());
}
}
Err(tera::Error::msg("Expected nonenmpty object"))
});
if let Value::Object(map) = v {
if let Some((_, v)) = map.iter().next() {
return Ok(v.clone());
}
}
Err(tera::Error::msg("Expected nonenmpty object"))
},
);
// opt(checked=foo.is_checked)
tera.register_function("opt", |args: &HashMap<String, Value>| -> tera::Result<Value> {
if args.len() != 1 {
return Err("Expected 1 argument".into());
}
match args.iter().nth(0) {
Some((name, &Value::Bool(true))) => {
Ok(Value::String(name.clone()))
},
Some((_, &Value::Bool(false))) => {
Ok(Value::Null)
},
_ => Err("Expected bool argument".into()),
}
});
tera.register_function(
"opt",
|args: &HashMap<String, Value>| -> tera::Result<Value> {
if args.len() != 1 {
return Err("Expected 1 argument".into());
}
match args.iter().nth(0) {
Some((name, &Value::Bool(true))) => Ok(Value::String(name.clone())),
Some((_, &Value::Bool(false))) => Ok(Value::Null),
_ => Err("Expected bool argument".into()),
}
},
);
// selected(val=foo.color,opt="Red")
tera.register_function("selected", |args: &HashMap<String, Value>| -> tera::Result<Value> {
match (args.get("val"), args.get("opt")) {
(Some(v), Some(w)) => {
if v == w {
Ok(Value::String("selected".into()))
} else {
Ok(Value::Null)
tera.register_function(
"selected",
|args: &HashMap<String, Value>| -> tera::Result<Value> {
match (args.get("val"), args.get("opt")) {
(Some(v), Some(w)) => {
if v == w {
Ok(Value::String("selected".into()))
} else {
Ok(Value::Null)
}
}
},
_ => Err("Expected val and opt args".into()),
}
});
_ => Err("Expected val and opt args".into()),
}
},
);
// TODO need to inject HttpRequest::url_for() into tera context, but it then can't be accessed by the functions.
// tera.register_function("url_for", |args: HashMap<String, Value>| -> tera::Result<Value> {
@ -117,19 +114,14 @@ async fn main() -> std::io::Result<()> {
debug!("Session key: {:?}", session_key);
HttpServer::new(move || {
let static_files = StaticFiles::new("/static", included_static_files())
.do_not_resolve_defaults();
let static_files =
StaticFiles::new("/static", included_static_files()).do_not_resolve_defaults();
App::new()
/* Middlewares */
.wrap(
CookieSession::signed(&session_key)
.secure(false)
)
.wrap(CookieSession::signed(&session_key).secure(false))
/* Bind shared objects */
.app_data(yopa_store.clone())
/* Routes */
.service(routes::index)
.service(routes::takeout)
@ -163,13 +155,15 @@ async fn main() -> std::io::Result<()> {
.service(routes::objects::delete)
//
.service(static_files)
.default_service(web::to(|| HttpResponse::NotFound().body("File or endpoint not found")))
.default_service(web::to(|| {
HttpResponse::NotFound().body("File or endpoint not found")
}))
})
.bind("127.0.0.1:8080")?
.run().await
.bind("127.0.0.1:8080")?
.run()
.await
}
fn init_yopa() -> YopaStoreWrapper {
let mut store = Storage::new();
@ -177,107 +171,123 @@ fn init_yopa() -> YopaStoreWrapper {
use yopa::model;
use yopa::DataType;
let id_recipe = store.define_object(model::ObjectModel {
id: Default::default(),
name: "Recipe".to_string(),
}).unwrap();
let id_book = store.define_object(model::ObjectModel {
id: Default::default(),
name: "Book".to_string(),
}).unwrap();
let id_ing = store.define_object(model::ObjectModel {
id: Default::default(),
name: "Ingredient".to_string(),
}).unwrap();
let val_descr = store.define_property(model::PropertyModel {
id: Default::default(),
object: id_recipe,
name: "description".to_string(),
optional: true,
multiple: true,
data_type: DataType::String,
default: TypedValue::String("".into()),
}).unwrap();
store.define_property(model::PropertyModel {
id: Default::default(),
object: id_book,
name: "author".to_string(),
optional: true,
multiple: true,
data_type: DataType::String,
default: TypedValue::String("Pepa Novák".into()),
}).unwrap();
let rel_book_id = store.define_relation(model::RelationModel {
id: Default::default(),
object: id_recipe,
name: "book reference".to_string(),
reciprocal_name: "recipes".to_string(),
optional: true,
multiple: true,
related: id_book,
}).unwrap();
let page = store.define_property(model::PropertyModel {
id: Default::default(),
object: rel_book_id,
name: "page".to_string(),
optional: true,
multiple: false,
data_type: DataType::Integer,
default: TypedValue::Integer(0),
}).unwrap();
store.define_relation(model::RelationModel {
id: Default::default(),
object: id_recipe,
name: "related recipe".to_string(),
reciprocal_name: "related recipe".to_string(),
optional: true,
multiple: true,
related: id_recipe,
}).unwrap();
let book1 = store.insert_object(InsertObj {
model: id_book,
name: "Book 1".to_string(),
values: vec![],
relations: vec![]
}).unwrap();
store.insert_object(InsertObj {
model: id_book,
name: "Book 2".to_string(),
values: vec![],
relations: vec![]
}).unwrap();
store.insert_object(InsertObj {
model: id_recipe,
name: "Recipe1".to_string(),
values: vec![
InsertValue {
let id_recipe = store
.define_object(model::ObjectModel {
id: Default::default(),
name: "Recipe".to_string(),
})
.unwrap();
let id_book = store
.define_object(model::ObjectModel {
id: Default::default(),
name: "Book".to_string(),
})
.unwrap();
let _id_ing = store
.define_object(model::ObjectModel {
id: Default::default(),
name: "Ingredient".to_string(),
})
.unwrap();
let val_descr = store
.define_property(model::PropertyModel {
id: Default::default(),
object: id_recipe,
name: "description".to_string(),
optional: true,
multiple: true,
data_type: DataType::String,
default: TypedValue::String("".into()),
})
.unwrap();
store
.define_property(model::PropertyModel {
id: Default::default(),
object: id_book,
name: "author".to_string(),
optional: true,
multiple: true,
data_type: DataType::String,
default: TypedValue::String("Pepa Novák".into()),
})
.unwrap();
let rel_book_id = store
.define_relation(model::RelationModel {
id: Default::default(),
object: id_recipe,
name: "book reference".to_string(),
reciprocal_name: "recipes".to_string(),
optional: true,
multiple: true,
related: id_book,
})
.unwrap();
let page = store
.define_property(model::PropertyModel {
id: Default::default(),
object: rel_book_id,
name: "page".to_string(),
optional: true,
multiple: false,
data_type: DataType::Integer,
default: TypedValue::Integer(0),
})
.unwrap();
store
.define_relation(model::RelationModel {
id: Default::default(),
object: id_recipe,
name: "related recipe".to_string(),
reciprocal_name: "related recipe".to_string(),
optional: true,
multiple: true,
related: id_recipe,
})
.unwrap();
let book1 = store
.insert_object(InsertObj {
model: id_book,
name: "Book 1".to_string(),
values: vec![],
relations: vec![],
})
.unwrap();
store
.insert_object(InsertObj {
model: id_book,
name: "Book 2".to_string(),
values: vec![],
relations: vec![],
})
.unwrap();
store
.insert_object(InsertObj {
model: id_recipe,
name: "Recipe1".to_string(),
values: vec![InsertValue {
model: val_descr,
value: TypedValue::String("Bla bla bla".into())
}
],
relations: vec![
InsertRel {
value: TypedValue::String("Bla bla bla".into()),
}],
relations: vec![InsertRel {
model: rel_book_id,
related: book1,
values: vec![
InsertValue {
model: page,
value: TypedValue::Integer(15)
}
]
}
]
}).unwrap();
values: vec![InsertValue {
model: page,
value: TypedValue::Integer(15),
}],
}],
})
.unwrap();
web::Data::new(tokio::sync::RwLock::new(store))
}

25
yopa-web/src/routes.rs
Unescape View File

@ -1,28 +1,17 @@
use std::fmt::{Debug, Display};
use std::ops::{DerefMut, Deref};
use std::str::FromStr;
use std::ops::Deref;
use actix_session::Session;
use actix_web::{HttpRequest, HttpResponse, Responder, web};
use actix_web::http::header::IntoHeaderValue;
use serde::{Deserialize, Serialize};
use yopa::{DataType, ID, Storage, StorageError, TypedValue};
use yopa::model::{ObjectModel, PropertyModel, RelationModel};
use crate::session_ext::SessionExt;
use crate::TERA;
use crate::tera_ext::TeraExt;
use crate::routes::models::relation::RelationModelDisplay;
use crate::routes::models::object::ObjectModelDisplay;
use actix_web::{HttpResponse, Responder};
pub(crate) mod models;
pub(crate) mod objects;
#[get("/")]
pub(crate) async fn index(session: Session, store: crate::YopaStoreWrapper) -> actix_web::Result<HttpResponse> {
objects::list_inner(session, store)
.await
pub(crate) async fn index(
session: Session,
store: crate::YopaStoreWrapper,
) -> actix_web::Result<HttpResponse> {
objects::list_inner(session, store).await
}
#[get("/takeout")]

61
yopa-web/src/routes/models.rs
Unescape View File

@ -1,17 +1,20 @@
use actix_session::Session;
use actix_web::Responder;
use crate::routes::models::relation::RelationModelDisplay;
use crate::routes::models::object::ObjectModelDisplay;
use crate::routes::models::relation::RelationModelDisplay;
use crate::session_ext::SessionExt;
use crate::TERA;
use crate::tera_ext::TeraExt;
use crate::TERA;
use actix_session::Session;
use actix_web::Responder;
pub(crate) mod object;
pub(crate) mod relation;
pub(crate) mod property;
pub(crate) mod relation;
#[get("/models")]
pub(crate) async fn list(session: Session, store: crate::YopaStoreWrapper) -> actix_web::Result<impl Responder> {
pub(crate) async fn list(
session: Session,
store: crate::YopaStoreWrapper,
) -> actix_web::Result<impl Responder> {
let rg = store.read().await;
let models_iter = rg.get_object_models();
@ -24,31 +27,37 @@ pub(crate) async fn list(session: Session, store: crate::YopaStoreWrapper) -> ac
let mut models = vec![];
for om in models_iter {
let mut relations = model_relations.remove(&om.id).unwrap_or_default();
let mut relations = relations.into_iter().map(|rm| {
let mut rprops = model_props.get(&rm.id).cloned().unwrap_or_default();
rprops.sort_by_key(|m| &m.name);
let relations = model_relations.remove(&om.id).unwrap_or_default();
let mut relations = relations
.into_iter()
.map(|rm| {
let mut rprops = model_props.get(&rm.id).cloned().unwrap_or_default();
rprops.sort_by_key(|m| &m.name);
RelationModelDisplay {
model: rm,
related_name: rg.get_model_name(rm.related),
properties: rprops,
}
}).collect::<Vec<_>>();
RelationModelDisplay {
model: rm,
related_name: rg.get_model_name(rm.related),
properties: rprops,
}
})
.collect::<Vec<_>>();
relations.sort_by_key(|d| &d.model.name);
// Relations coming INTO this model
let mut reciprocal_relations = model_rec_relations.remove(&om.id).unwrap_or_default();
let mut reciprocal_relations = reciprocal_relations.into_iter().map(|rm| {
let mut rprops = model_props.get(&rm.id).cloned().unwrap_or_default();
rprops.sort_by_key(|m| &m.name);
let reciprocal_relations = model_rec_relations.remove(&om.id).unwrap_or_default();
let mut reciprocal_relations = reciprocal_relations
.into_iter()
.map(|rm| {
let mut rprops = model_props.get(&rm.id).cloned().unwrap_or_default();
rprops.sort_by_key(|m| &m.name);
RelationModelDisplay {
model: rm,
related_name: rg.get_model_name(rm.object),
properties: rprops,
}
}).collect::<Vec<_>>();
RelationModelDisplay {
model: rm,
related_name: rg.get_model_name(rm.object),
properties: rprops,
}
})
.collect::<Vec<_>>();
reciprocal_relations.sort_by_key(|d| &d.model.reciprocal_name);
let mut properties = model_props.remove(&om.id).unwrap_or_default();

19
yopa-web/src/routes/models/object.rs
Unescape View File

@ -1,15 +1,15 @@
use actix_session::Session;
use actix_web::{Responder, web};
use actix_web::{web, Responder};
use serde::{Deserialize, Serialize};
use yopa::ID;
use yopa::model::{ObjectModel, PropertyModel};
use yopa::ID;
use crate::routes::models::relation::RelationModelDisplay;
use crate::session_ext::SessionExt;
use crate::TERA;
use crate::tera_ext::TeraExt;
use crate::utils::redirect;
use crate::TERA;
#[derive(Serialize, Debug)]
pub(crate) struct ObjectModelDisplay<'a> {
@ -60,7 +60,7 @@ pub(crate) async fn create(
Err(e) => {
warn!("Error creating model: {}", e);
session.flash_error(e.to_string());
session.set("old", form);
session.set("old", form).unwrap();
redirect("/model/object/create")
}
}
@ -76,7 +76,8 @@ pub(crate) async fn update_form(
session.render_flash(&mut context);
let rg = store.read().await;
let model = rg.get_object_model(*model_id)
let model = rg
.get_object_model(*model_id)
.ok_or_else(|| actix_web::error::ErrorNotFound("No such model"))?;
// Re-fill old values
@ -114,13 +115,12 @@ pub(crate) async fn update(
Err(e) => {
warn!("Error updating model: {}", e);
session.flash_error(e.to_string());
session.set("old", form);
session.set("old", form).unwrap();
redirect(format!("/model/object/update/{}", id))
}
}
}
#[get("/model/object/delete/{id}")]
pub(crate) async fn delete(
id: web::Path<String>,
@ -128,7 +128,10 @@ pub(crate) async fn delete(
session: Session,
) -> actix_web::Result<impl Responder> {
let mut wg = store.write().await;
match wg.undefine_object(id.parse().map_err(|e| actix_web::error::ErrorBadRequest(e))?) {
match wg.undefine_object(
id.parse()
.map_err(|e| actix_web::error::ErrorBadRequest(e))?,
) {
Ok(om) => {
debug!("Object model deleted, redirecting to root");
session.flash_success(format!("Object model \"{}\" deleted.", om.name));

76
yopa-web/src/routes/models/property.rs
Unescape View File

@ -1,15 +1,15 @@
use actix_session::Session;
use actix_web::{Responder, web};
use serde::{Serialize, Deserialize};
use actix_web::{web, Responder};
use serde::{Deserialize, Serialize};
use yopa::{DataType, ID, TypedValue};
use yopa::model::{PropertyModel, RelationModel};
use yopa::model::PropertyModel;
use yopa::{DataType, TypedValue, ID};
use crate::routes::models::relation::ObjectOrRelationModelDisplay;
use crate::session_ext::SessionExt;
use crate::TERA;
use crate::tera_ext::TeraExt;
use crate::utils::{ParseOrBadReq, redirect};
use crate::routes::models::relation::ObjectOrRelationModelDisplay;
use crate::utils::{redirect, ParseOrBadReq};
use crate::TERA;
#[get("/model/property/create/{object_id}")]
pub(crate) async fn create_form(
@ -26,14 +26,17 @@ pub(crate) async fn create_form(
if let Ok(Some(form)) = session.take::<PropertyModelCreateForm>("old") {
context.insert("old", &form);
} else {
context.insert("old", &PropertyModelCreateForm {
object: Default::default(),
name: "".to_string(),
optional: true,
multiple: false,
data_type: DataType::String,
default: "".to_string()
});
context.insert(
"old",
&PropertyModelCreateForm {
object: Default::default(),
name: "".to_string(),
optional: true,
multiple: false,
data_type: DataType::String,
default: "".to_string(),
},
);
}
debug!("ID = {}", object_id);
@ -60,7 +63,7 @@ pub(crate) async fn create_form(
TERA.build_response("models/property_create", &context)
}
#[derive(Serialize,Deserialize)]
#[derive(Serialize, Deserialize)]
pub(crate) struct PropertyModelCreateForm {
pub object: ID,
pub name: String,
@ -74,20 +77,19 @@ pub(crate) struct PropertyModelCreateForm {
pub default: String,
}
fn parse_default(data_type : DataType, default : String) -> Result<TypedValue, String> {
fn parse_default(data_type: DataType, default: String) -> Result<TypedValue, String> {
Ok(match data_type {
DataType::String => {
TypedValue::String(default.into())
}
DataType::String => TypedValue::String(default.into()),
DataType::Integer => {
if default.is_empty() {
TypedValue::Integer(0)
} else {
// TODO better error reporting
TypedValue::Integer(default.parse()
.map_err(|_| {
format!("Error parsing \"{}\" as integer", default)
})?)
TypedValue::Integer(
default
.parse()
.map_err(|_| format!("Error parsing \"{}\" as integer", default))?,
)
}
}
DataType::Decimal => {
@ -95,10 +97,11 @@ fn parse_default(data_type : DataType, default : String) -> Result<TypedValue, S
TypedValue::Decimal(0.0)
} else {
// TODO better error reporting
TypedValue::Decimal(default.parse()
.map_err(|_| {
format!("Error parsing \"{}\" as decimal", default)
})?)
TypedValue::Decimal(
default
.parse()
.map_err(|_| format!("Error parsing \"{}\" as decimal", default))?,
)
}
}
DataType::Boolean => {
@ -106,9 +109,8 @@ fn parse_default(data_type : DataType, default : String) -> Result<TypedValue, S
TypedValue::Boolean(false)
} else {
TypedValue::String(default.clone().into())
.cast_to(DataType::Boolean).map_err(|_| {
format!("Error parsing \"{}\" as boolean", default)
})?
.cast_to(DataType::Boolean)
.map_err(|_| format!("Error parsing \"{}\" as boolean", default))?
}
}
})
@ -131,7 +133,7 @@ pub(crate) async fn create(
Err(msg) => {
warn!("{}", msg);
session.flash_error(msg);
session.set("old", &form);
session.set("old", &form).unwrap();
return redirect(format!("/model/property/create/{}", form.object));
}
};
@ -153,7 +155,7 @@ pub(crate) async fn create(
Err(e) => {
warn!("Error creating property model: {}", e);
session.flash_error(e.to_string());
session.set("old", &form);
session.set("old", &form).unwrap();
redirect(format!("/model/property/create/{}", form.object))
}
}
@ -193,7 +195,6 @@ pub(crate) struct PropertyModelEditForm {
pub default: String,
}
#[get("/model/property/update/{model_id}")]
pub(crate) async fn update_form(
model_id: web::Path<ID>,
@ -204,7 +205,8 @@ pub(crate) async fn update_form(
session.render_flash(&mut context);
let rg = store.read().await;
let model = rg.get_property_model(*model_id)
let model = rg
.get_property_model(*model_id)
.ok_or_else(|| actix_web::error::ErrorNotFound("No such model"))?;
// Re-fill old values
@ -239,7 +241,7 @@ pub(crate) async fn update(
Err(msg) => {
warn!("{}", msg);
session.flash_error(msg);
session.set("old", form);
session.set("old", form).unwrap();
return redirect(format!("/model/property/update/{}", id));
}
};
@ -261,7 +263,7 @@ pub(crate) async fn update(
Err(e) => {
warn!("Error updating model: {}", e);
session.flash_error(e.to_string());
session.set("old", form);
session.set("old", form).unwrap();
redirect(format!("/model/relation/update/{}", id))
}
}

45
yopa-web/src/routes/models/relation.rs
Unescape View File

@ -1,14 +1,14 @@
use actix_session::Session;
use actix_web::{Responder, web};
use serde::{Serialize, Deserialize};
use actix_web::{web, Responder};
use serde::{Deserialize, Serialize};
use yopa::ID;
use yopa::model::{PropertyModel, RelationModel};
use yopa::ID;
use crate::session_ext::SessionExt;
use crate::TERA;
use crate::tera_ext::TeraExt;
use crate::utils::{ParseOrBadReq, redirect};
use crate::utils::{redirect, ParseOrBadReq};
use crate::TERA;
#[derive(Serialize, Debug)]
pub(crate) struct RelationModelDisplay<'a> {
@ -33,17 +33,21 @@ pub(crate) async fn create_form(
if let Ok(Some(form)) = session.take::<RelationModelCreateForm>("old") {
context.insert("old", &form);
} else {
context.insert("old", &RelationModelCreateForm {
object: Default::default(),
name: "".to_string(),
reciprocal_name: "".to_string(),
optional: false,
multiple: false,
related: Default::default()
});
context.insert(
"old",
&RelationModelCreateForm {
object: Default::default(),
name: "".to_string(),
reciprocal_name: "".to_string(),
optional: false,
multiple: false,
related: Default::default(),
},
);
}
let object = rg.get_object_model(object_id.parse_or_bad_request()?)
let object = rg
.get_object_model(object_id.parse_or_bad_request()?)
.ok_or_else(|| actix_web::error::ErrorNotFound("No such source object"))?;
let mut models: Vec<_> = rg.get_object_models().collect();
@ -56,7 +60,7 @@ pub(crate) async fn create_form(
TERA.build_response("models/relation_create", &context)
}
#[derive(Serialize,Deserialize)]
#[derive(Serialize, Deserialize)]
pub(crate) struct RelationModelCreateForm {
pub object: ID,
pub name: String,
@ -93,7 +97,7 @@ pub(crate) async fn create(
Err(e) => {
warn!("Error creating relation model: {}", e);
session.flash_error(e.to_string());
session.set("old", &form);
session.set("old", &form).unwrap();
redirect(format!("/model/relation/create/{}", form.object))
}
}
@ -126,7 +130,7 @@ pub(crate) async fn delete(
}
}
#[derive(Serialize,Deserialize)]
#[derive(Serialize, Deserialize)]
pub(crate) struct RelationModelEditForm {
pub name: String,
pub reciprocal_name: String,
@ -146,7 +150,8 @@ pub(crate) async fn update_form(
session.render_flash(&mut context);
let rg = store.read().await;
let model = rg.get_relation_model(*model_id)
let model = rg
.get_relation_model(*model_id)
.ok_or_else(|| actix_web::error::ErrorNotFound("No such model"))?;
// Re-fill old values
@ -181,7 +186,7 @@ pub(crate) async fn update(
reciprocal_name: form.reciprocal_name.to_string(),
optional: form.optional,
multiple: form.multiple,
related: Default::default() // dummy
related: Default::default(), // dummy
}) {
Ok(_id) => {
debug!("Relation updated, redirecting to root");
@ -191,7 +196,7 @@ pub(crate) async fn update(
Err(e) => {
warn!("Error updating model: {}", e);
session.flash_error(e.to_string());
session.set("old", form);
session.set("old", form).unwrap();
redirect(format!("/model/relation/update/{}", id))
}
}

226
yopa-web/src/routes/objects.rs
Unescape View File

@ -1,21 +1,20 @@
use actix_session::Session;
use actix_web::{Responder, web, HttpResponse};
use crate::session_ext::SessionExt;
use crate::routes::models::object::ObjectModelForm;
use crate::TERA;
use actix_session::Session;
use actix_web::{web, HttpResponse, Responder};
use crate::tera_ext::TeraExt;
use yopa::{ID, model, Storage, data, TypedValue};
use yopa::data::Object;
use serde::{Serialize,Deserialize};
use yopa::insert::{InsertObj, InsertValue};
use crate::utils::redirect;
use actix_web::web::Json;
use serde_json::Value;
use itertools::Itertools;
use yopa::model::{ObjectModel, PropertyModel, RelationModel};
use crate::TERA;
use serde::Serialize;
use yopa::data::Object;
use yopa::insert::InsertObj;
use yopa::{data, model, Storage, ID};
use heck::TitleCase;
use std::collections::HashMap;
use itertools::Itertools;
use json_dotpath::DotPaths;
use std::collections::HashMap;
use yopa::model::{ObjectModel, PropertyModel, RelationModel};
use yopa::update::UpdateObj;
// we only need references here, Context serializes everything to Value.
@ -28,7 +27,7 @@ pub struct Schema<'a> {
pub prop_models: Vec<&'a model::PropertyModel>,
}
#[derive(Serialize,Debug,Clone)]
#[derive(Serialize, Debug, Clone)]
pub struct ObjectCreateData<'a> {
pub model_id: ID,
pub schema: Schema<'a>,
@ -39,14 +38,15 @@ pub struct ObjectCreateData<'a> {
pub(crate) async fn create_form(
model_id: web::Path<ID>,
store: crate::YopaStoreWrapper,
session: Session
session: Session,
) -> actix_web::Result<impl Responder> {
let mut context = tera::Context::new();
session.render_flash(&mut context);
let rg = store.read().await;
let model = rg.get_object_model(*model_id)
let model = rg
.get_object_model(*model_id)
.ok_or_else(|| actix_web::error::ErrorNotFound("No such model"))?;
context.insert("model", model);
@ -58,19 +58,20 @@ pub(crate) async fn create_form(
TERA.build_response("objects/object_create", &context)
}
fn prepare_object_create_data(rg : &Storage, model_id : ID) -> actix_web::Result<ObjectCreateData> {
let model = rg.get_object_model(model_id)
fn prepare_object_create_data(rg: &Storage, model_id: ID) -> actix_web::Result<ObjectCreateData> {
let model = rg
.get_object_model(model_id)
.ok_or_else(|| actix_web::error::ErrorNotFound("No such model"))?;
let relations : Vec<_> = rg.get_relation_models_for_object_model(model.id).collect();
let relations: Vec<_> = rg.get_relation_models_for_object_model(model.id).collect();
let mut prop_object_ids : Vec<ID> = relations.iter().map(|r| r.id).collect();
let mut prop_object_ids: Vec<ID> = relations.iter().map(|r| r.id).collect();
prop_object_ids.push(model.id);
prop_object_ids.sort();
prop_object_ids.dedup();
let mut related_ids : Vec<_> = relations.iter().map(|r| r.related).collect();
let mut related_ids: Vec<_> = relations.iter().map(|r| r.related).collect();
related_ids.sort();
related_ids.dedup();
@ -80,9 +81,11 @@ fn prepare_object_create_data(rg : &Storage, model_id : ID) -> actix_web::Result
schema: Schema {
obj_models: rg.get_object_models().collect(), // TODO get only the ones that matter here
rel_models: relations,
prop_models: rg.get_property_models_for_parents(prop_object_ids).collect()
prop_models: rg
.get_property_models_for_parents(prop_object_ids)
.collect(),
},
objects: rg.get_objects_of_type(related_ids).collect()
objects: rg.get_objects_of_type(related_ids).collect(),
})
}
@ -120,30 +123,35 @@ pub(crate) async fn create(
#[derive(Debug, Serialize, Clone)]
struct ModelWithObjects<'a> {
model : &'a ObjectModel,
objects: Vec<&'a Object>
model: &'a ObjectModel,
objects: Vec<&'a Object>,
}
#[get("/objects")]
pub(crate) async fn list(session: Session, store: crate::YopaStoreWrapper) -> actix_web::Result<impl Responder> {
pub(crate) async fn list(
session: Session,
store: crate::YopaStoreWrapper,
) -> actix_web::Result<impl Responder> {
list_inner(session, store).await
}
pub(crate) async fn list_inner(session: Session, store: crate::YopaStoreWrapper) -> actix_web::Result<HttpResponse> {
pub(crate) async fn list_inner(
session: Session,
store: crate::YopaStoreWrapper,
) -> actix_web::Result<HttpResponse> {
let rg = store.read().await;
let mut objects_by_model = rg.get_grouped_objects();
let mut models : Vec<_> = rg.get_object_models()
let models: Vec<_> = rg
.get_object_models()
.sorted_by_key(|m| &m.name)
.map(|model| {
let mut objects = objects_by_model.remove(&model.id).unwrap_or_default();
objects.sort_by_key(|o| &o.name);
ModelWithObjects {
model,
objects
}
}).collect();
ModelWithObjects { model, objects }
})
.collect();
let mut ctx = tera::Context::new();
ctx.insert("models", &models);
@ -152,31 +160,30 @@ pub(crate) async fn list_inner(session: Session, store: crate::YopaStoreWrapper)
TERA.build_response("objects/index", &ctx)
}
#[derive(Debug,Serialize)]
#[derive(Debug, Serialize)]
struct PropertyView<'a> {
model : &'a PropertyModel,
values: Vec<&'a yopa::data::Value>
model: &'a PropertyModel,
values: Vec<&'a yopa::data::Value>,
}
#[derive(Debug,Serialize)]
#[derive(Debug, Serialize)]
struct RelationView<'a> {
model : &'a RelationModel,
model: &'a RelationModel,
related_name: &'a str,
instances: Vec<RelationInstanceView<'a>>
instances: Vec<RelationInstanceView<'a>>,
}
#[derive(Debug,Serialize)]
#[derive(Debug, Serialize)]
struct RelationInstanceView<'a> {
related: &'a Object,
properties: Vec<PropertyView<'a>>
properties: Vec<PropertyView<'a>>,
}
#[get("/object/detail/{id}")]
pub(crate) async fn detail(
id: web::Path<ID>,
store: crate::YopaStoreWrapper,
session: Session
session: Session,
) -> actix_web::Result<impl Responder> {
let object_id = *id;
@ -185,18 +192,22 @@ pub(crate) async fn detail(
let rg = store.read().await;
let object = rg.get_object(object_id)
let object = rg
.get_object(object_id)
.ok_or_else(|| actix_web::error::ErrorNotFound("No such object"))?;
let model = rg.get_object_model(object.model)
let model = rg
.get_object_model(object.model)
.ok_or_else(|| actix_web::error::ErrorNotFound("No such model"))?;
context.insert("object", object);
context.insert("model", model);
context.insert("kind", &rg.get_model_name(object.model));
let mut relations = rg.get_relations_for_object(object_id).collect_vec();
let reci_relations = rg.get_reciprocal_relations_for_object(object_id).collect_vec();
let relations = rg.get_relations_for_object(object_id).collect_vec();
let reci_relations = rg
.get_reciprocal_relations_for_object(object_id)
.collect_vec();
// values by parent ID
let mut ids_to_get_values_for = relations.iter().map(|r| r.id).collect_vec();
@ -207,15 +218,17 @@ pub(crate) async fn detail(
// object's own properties
{
let mut object_values_by_model = grouped_values
.remove(&object_id).unwrap_or_default().into_iter()
let object_values_by_model = grouped_values
.remove(&object_id)
.unwrap_or_default()
.into_iter()
.into_group_map_by(|value| value.model);
let mut view_object_properties = vec![];
for (prop_model_id, values) in object_values_by_model {
view_object_properties.push(PropertyView {
model: rg.get_property_model(prop_model_id).unwrap(),
values
values,
})
}
@ -226,7 +239,8 @@ pub(crate) async fn detail(
// go through relations
{
let grouped_relations = relations.iter()
let grouped_relations = relations
.iter()
.into_group_map_by(|relation| relation.model);
let mut relation_views = vec![];
@ -236,18 +250,20 @@ pub(crate) async fn detail(
for rel in relations {
let related_obj = match rg.get_object(rel.related) {
None => continue,
Some(obj) => obj
Some(obj) => obj,
};
let mut rel_values_by_model = grouped_values
.remove(&rel.id).unwrap_or_default().into_iter()
let rel_values_by_model = grouped_values
.remove(&rel.id)
.unwrap_or_default()
.into_iter()
.into_group_map_by(|value| value.model);
let mut view_rel_properties = vec![];
for (prop_model_id, values) in rel_values_by_model {
view_rel_properties.push(PropertyView {
model: rg.get_property_model(prop_model_id).unwrap(),
values
values,
})
}
@ -255,7 +271,7 @@ pub(crate) async fn detail(
instances.push(RelationInstanceView {
related: related_obj,
properties: view_rel_properties
properties: view_rel_properties,
})
}
@ -264,7 +280,7 @@ pub(crate) async fn detail(
relation_views.push(RelationView {
model: rg.get_relation_model(model_id).unwrap(),
related_name: rg.get_model_name(model_id),
instances
instances,
})
}
@ -275,7 +291,8 @@ pub(crate) async fn detail(
// near-copypasta for reciprocal
{
let grouped_relations = reci_relations.iter()
let grouped_relations = reci_relations
.iter()
.into_group_map_by(|relation| relation.model);
let mut relation_views = vec![];
@ -285,18 +302,20 @@ pub(crate) async fn detail(
for rel in relations {
let related_obj = match rg.get_object(rel.object) {
None => continue,
Some(obj) => obj
Some(obj) => obj,
};
let mut rel_values_by_model = grouped_values
.remove(&rel.id).unwrap_or_default().into_iter()
let rel_values_by_model = grouped_values
.remove(&rel.id)
.unwrap_or_default()
.into_iter()
.into_group_map_by(|value| value.model);
let mut view_rel_properties = vec![];
for (prop_model_id, values) in rel_values_by_model {
view_rel_properties.push(PropertyView {
model: rg.get_property_model(prop_model_id).unwrap(),
values
values,
})
}
@ -304,7 +323,7 @@ pub(crate) async fn detail(
instances.push(RelationInstanceView {
related: related_obj,
properties: view_rel_properties
properties: view_rel_properties,
})
}
@ -313,7 +332,7 @@ pub(crate) async fn detail(
relation_views.push(RelationView {
model: rg.get_relation_model(model_id).unwrap(),
related_name: rg.get_model_name(model_id),
instances
instances,
})
}
@ -325,16 +344,19 @@ pub(crate) async fn detail(
TERA.build_response("objects/object_detail", &context)
}
#[derive(Serialize,Debug,Clone)]
#[derive(Serialize, Debug, Clone)]
struct EnrichedObject<'a> {
id: ID,
model: ID,
name: String,
values: HashMap<String /* ID but as string so serde will stop exploding */, Vec<&'a data::Value>>,
values: HashMap<
String, /* ID but as string so serde will stop exploding */
Vec<&'a data::Value>,
>,
relations: HashMap<String /* ID */, Vec<EnrichedRelation<'a>>>,
}
#[derive(Serialize,Debug,Clone)]
#[derive(Serialize, Debug, Clone)]
struct EnrichedRelation<'a> {
id: ID,
object: ID,
@ -347,17 +369,19 @@ struct EnrichedRelation<'a> {
pub(crate) async fn update_form(
id: web::Path<ID>,
store: crate::YopaStoreWrapper,
session: Session
session: Session,
) -> actix_web::Result<impl Responder> {
let mut context = tera::Context::new();
session.render_flash(&mut context);
let rg = store.read().await;
let object = rg.get_object(*id)
let object = rg
.get_object(*id)
.ok_or_else(|| actix_web::error::ErrorNotFound("No such object"))?;
let model = rg.get_object_model(object.model)
let model = rg
.get_object_model(object.model)
.ok_or_else(|| actix_web::error::ErrorNotFound("Object has no model"))?;
// maybe its useful,idk
@ -370,47 +394,71 @@ pub(crate) async fn update_form(
let mut relation_map = HashMap::new();
// Some properties may have no values, so we first check what IDs to expect
let prop_ids = create_data.schema.prop_models.iter()
.filter(|p| p.object == model.id).map(|p| p.id).collect_vec();
let prop_ids = create_data
.schema
.prop_models
.iter()
.filter(|p| p.object == model.id)
.map(|p| p.id)
.collect_vec();
let mut values_grouped = rg.get_values_for_object(*id)
.into_group_map_by(|v| v.model);
let mut values_grouped = rg.get_values_for_object(*id).into_group_map_by(|v| v.model);
prop_ids.into_iter().for_each(|id| {
value_map.insert(id.to_string(), values_grouped.remove(&id).unwrap_or_default());
value_map.insert(
id.to_string(),
values_grouped.remove(&id).unwrap_or_default(),
);
});
{
// Some properties may have no values, so we first check what IDs to expect
let relation_model_ids = create_data.schema.rel_models.iter()
let relation_model_ids = create_data
.schema
.rel_models
.iter()
.filter(|p| p.object == model.id)
.map(|p| p.id).collect_vec();
.map(|p| p.id)
.collect_vec();
let relations = rg.get_relations_for_object(*id).collect_vec();
let relation_ids = relations.iter().map(|r| r.id).collect_vec();
let mut relations_grouped_by_model = relations.iter()
let mut relations_grouped_by_model = relations
.iter()
.into_group_map_by(|relation| relation.model);
let mut property_models_grouped_by_parent = rg.get_grouped_prop_models_for_parents(relation_model_ids.clone());
let mut property_models_grouped_by_parent =
rg.get_grouped_prop_models_for_parents(relation_model_ids.clone());
let mut relation_values_grouped_by_instance = rg.get_grouped_values_for_objects(relation_ids);
let mut relation_values_grouped_by_instance =
rg.get_grouped_values_for_objects(relation_ids);
for rel_model_id in relation_model_ids {
let relations = relations_grouped_by_model.remove(&rel_model_id).unwrap_or_default();
let relations = relations_grouped_by_model
.remove(&rel_model_id)
.unwrap_or_default();
let mut instances = vec![];
let prop_models_for_relation = property_models_grouped_by_parent.remove(&rel_model_id).unwrap_or_default();
let prop_models_for_relation = property_models_grouped_by_parent
.remove(&rel_model_id)
.unwrap_or_default();
for rel in relations {
let mut relation_values_map = HashMap::new();
// values keyed by model
let mut rel_values = relation_values_grouped_by_instance.remove(&rel.id).unwrap_or_default().into_iter()
let mut rel_values = relation_values_grouped_by_instance
.remove(&rel.id)
.unwrap_or_default()
.into_iter()
.into_group_map_by(|relation| relation.model);
prop_models_for_relation.iter().for_each(|prop_model| {
relation_values_map.insert(prop_model.id.to_string(), rel_values.remove(&prop_model.id).unwrap_or_default());
relation_values_map.insert(
prop_model.id.to_string(),
rel_values.remove(&prop_model.id).unwrap_or_default(),
);
});
instances.push(EnrichedRelation {
@ -418,7 +466,7 @@ pub(crate) async fn update_form(
object: rel.object,
model: rel.model,
related: rel.related,
values: relation_values_map
values: relation_values_map,
});
}
@ -433,7 +481,7 @@ pub(crate) async fn update_form(
model: object.model,
name: object.name.clone(),
values: value_map,
relations: relation_map
relations: relation_map,
};
form.dot_remove("model_id").unwrap();
@ -443,10 +491,9 @@ pub(crate) async fn update_form(
TERA.build_response("objects/object_update", &context)
}
#[post("/object/update/{id}")]
pub(crate) async fn update(
id: web::Path<ID>,
_id: web::Path<ID>,
form: web::Json<UpdateObj>,
store: crate::YopaStoreWrapper,
session: Session,
@ -457,7 +504,8 @@ pub(crate) async fn update(
let form = form.into_inner();
let name = form.name.clone();
let object = wg.get_object(form.id)
let object = wg
.get_object(form.id)
.ok_or_else(|| actix_web::error::ErrorNotFound("No such object"))?;
let model_name = wg.get_model_name(object.model).to_owned().to_title_case();

41
yopa-web/src/tera_ext.rs
Unescape View File

@ -3,9 +3,20 @@ use actix_web::HttpResponse;
use include_dir::Dir;
use tera::Tera;
fn tera_includedir_walk_folder_inner(collected: &mut Vec<(String, String)>, tera: &mut Tera, dir: &Dir) {
fn tera_includedir_walk_folder_inner(
collected: &mut Vec<(String, String)>,
tera: &mut Tera,
dir: &Dir,
) {
for f in dir.files() {
let halves: Vec<_> = f.path().file_name().unwrap().to_str().unwrap().split('.').collect();
let halves: Vec<_> = f
.path()
.file_name()
.unwrap()
.to_str()
.unwrap()
.split('.')
.collect();
if halves.last().unwrap() != &"tera" {
debug!("Bad file: {:?}", f);
@ -30,11 +41,20 @@ fn tera_includedir_walk_folder_inner(collected: &mut Vec<(String, String)>, tera
pub(crate) trait TeraExt {
fn add_include_dir_templates(&mut self, dir: &Dir) -> tera::Result<()>;
fn build_response(&self, template: &str, context: &tera::Context) -> actix_web::Result<HttpResponse> {
fn build_response(
&self,
template: &str,
context: &tera::Context,
) -> actix_web::Result<HttpResponse> {
self.build_err_response(StatusCode::OK, template, context)
}
fn build_err_response(&self, code: StatusCode, template: &str, context: &tera::Context) -> actix_web::Result<HttpResponse>;
fn build_err_response(
&self,
code: StatusCode,
template: &str,
context: &tera::Context,
) -> actix_web::Result<HttpResponse>;
}
impl TeraExt for Tera {
@ -45,10 +65,15 @@ impl TeraExt for Tera {
self.add_raw_templates(templates)
}
fn build_err_response(&self, code: StatusCode, template: &str, context: &tera::Context) -> actix_web::Result<HttpResponse> {
let html = self.render(template, context).map_err(|e| {
actix_web::error::ErrorInternalServerError(e)
})?;
fn build_err_response(
&self,
code: StatusCode,
template: &str,
context: &tera::Context,
) -> actix_web::Result<HttpResponse> {
let html = self
.render(template, context)
.map_err(|e| actix_web::error::ErrorInternalServerError(e))?;
Ok(HttpResponse::build(code).body(html))
}

29
yopa-web/src/utils.rs
Unescape View File

@ -1,7 +1,7 @@
use actix_web::http::header::IntoHeaderValue;
use actix_web::HttpResponse;
use std::fmt::{Debug, Display};
use std::str::FromStr;
use std::fmt::{Display, Debug};
pub fn redirect(path: impl IntoHeaderValue) -> actix_web::Result<HttpResponse> {
Ok(HttpResponse::SeeOther()
@ -11,29 +11,30 @@ pub fn redirect(path: impl IntoHeaderValue) -> actix_web::Result<HttpResponse> {
pub trait ParseOrBadReq {
fn parse_or_bad_request<T, E>(&self) -> actix_web::Result<T>
where T: FromStr<Err=E>,
E: Display + Debug + 'static;
where
T: FromStr<Err = E>,
E: Display + Debug + 'static;
}
impl ParseOrBadReq for &str {
fn parse_or_bad_request<T, E>(&self) -> actix_web::Result<T>
where T: FromStr<Err=E>,
E: Display + Debug + 'static
where
T: FromStr<Err = E>,
E: Display + Debug + 'static,
{
self.parse::<T>()
.map_err(|e| {
error!("Parse error for \"{}\"", self);
actix_web::error::ErrorBadRequest(e)
})
self.parse::<T>().map_err(|e| {
error!("Parse error for \"{}\"", self);
actix_web::error::ErrorBadRequest(e)
})
}
}
impl ParseOrBadReq for String {
fn parse_or_bad_request<T, E>(&self) -> actix_web::Result<T>
where T: FromStr<Err=E>,
E: Display + Debug + 'static
where
T: FromStr<Err = E>,
E: Display + Debug + 'static,
{
self.as_str()
.parse_or_bad_request()
self.as_str().parse_or_bad_request()
}
}

5
yopa/src/cool.rs
Unescape View File

@ -4,7 +4,10 @@ use std::collections::HashMap;
use std::hash::Hash;
/// drain_filter() implemented for HashMap. It returns the removed items as a Vec
pub fn map_drain_filter<K: Eq + Hash, V>(map: &mut HashMap<K, V>, filter: impl Fn(&K, &V) -> bool) -> Vec<(K, V)> {
pub fn map_drain_filter<K: Eq + Hash, V>(
map: &mut HashMap<K, V>,
filter: impl Fn(&K, &V) -> bool,
) -> Vec<(K, V)> {
let mut removed = vec![];
let mut retain = vec![];
for (k, v) in map.drain() {

297
yopa/src/data.rs
Unescape View File

@ -4,11 +4,11 @@ use std::borrow::Cow;
use serde::{Deserialize, Serialize};
use crate::ID;
use crate::model::DataType;
use crate::id::HaveId;
use std::fmt::{Display, Formatter};
use crate::model::DataType;
use crate::ID;
use std::fmt;
use std::fmt::{Display, Formatter};
/// Value of a particular type
#[derive(Debug, Clone, Serialize, Deserialize, PartialEq)]
@ -40,43 +40,41 @@ impl TypedValue {
match (self, ty) {
// to string
(s @ TypedValue::String(_), DataType::String) => Ok(s),
(TypedValue::Integer(i), DataType::String) => Ok(TypedValue::String(i.to_string().into())),
(TypedValue::Decimal(f), DataType::String) => Ok(TypedValue::String(f.to_string().into())),
(TypedValue::Boolean(b), DataType::String) => Ok(TypedValue::String(Cow::Borrowed(if b { "1" } else { "0" }))),
// to int
(TypedValue::String(s), DataType::Integer) => {
match s.parse::<i64>() {
Ok(i) => Ok(TypedValue::Integer(i)),
Err(_) => Err(TypedValue::String(s))
}
(TypedValue::Integer(i), DataType::String) => {
Ok(TypedValue::String(i.to_string().into()))
}
(TypedValue::Decimal(f), DataType::String) => {
Ok(TypedValue::String(f.to_string().into()))
}
(TypedValue::Boolean(b), DataType::String) => {
Ok(TypedValue::String(Cow::Borrowed(if b { "1" } else { "0" })))
}
// to int
(TypedValue::String(s), DataType::Integer) => match s.parse::<i64>() {
Ok(i) => Ok(TypedValue::Integer(i)),
Err(_) => Err(TypedValue::String(s)),
},
(s @ TypedValue::Integer(_), DataType::Integer) => Ok(s),
(TypedValue::Decimal(f), DataType::Integer) => Ok(TypedValue::Integer(f.round() as i64)),
(TypedValue::Boolean(b), DataType::Integer) => Ok(TypedValue::Integer(if b { 1 } else { 0 })),
// to float
(TypedValue::String(s), DataType::Decimal) => {
match s.parse::<f64>() {
Ok(i) => Ok(TypedValue::Decimal(i)),
Err(_) => Err(TypedValue::String(s))
}
(TypedValue::Decimal(f), DataType::Integer) => {
Ok(TypedValue::Integer(f.round() as i64))
}
(TypedValue::Boolean(b), DataType::Integer) => {
Ok(TypedValue::Integer(if b { 1 } else { 0 }))
}
// to float
(TypedValue::String(s), DataType::Decimal) => match s.parse::<f64>() {
Ok(i) => Ok(TypedValue::Decimal(i)),
Err(_) => Err(TypedValue::String(s)),
},
(TypedValue::Integer(i), DataType::Decimal) => Ok(TypedValue::Decimal(i as f64)),
(d @ TypedValue::Decimal(_), DataType::Decimal) => Ok(d),
(e @ TypedValue::Boolean(_), DataType::Decimal) => Err(e),
// to bool
(TypedValue::String(s), DataType::Boolean) => {
match &(&s).to_ascii_lowercase()[..] {
"y" | "yes" | "true" | "1" => {
Ok(TypedValue::Boolean(true))
}
"n" | "no" | "false" | "0" => {
Ok(TypedValue::Boolean(false))
}
_ => {
Err(TypedValue::String(s))
}
}
}
(TypedValue::String(s), DataType::Boolean) => match &(&s).to_ascii_lowercase()[..] {
"y" | "yes" | "true" | "1" => Ok(TypedValue::Boolean(true)),
"n" | "no" | "false" | "0" => Ok(TypedValue::Boolean(false)),
_ => Err(TypedValue::String(s)),
},
(TypedValue::Integer(i), DataType::Boolean) => Ok(TypedValue::Boolean(i != 0)),
(e @ TypedValue::Decimal(_), DataType::Boolean) => Err(e),
(b @ TypedValue::Boolean(_), DataType::Boolean) => Ok(b),
@ -93,78 +91,213 @@ mod tests {
#[test]
fn test_cast_to_bool() {
// Cast to bool
assert_eq!(Ok(TypedValue::Boolean(true)), TypedValue::Boolean(true).cast_to(DataType::Boolean));
assert_eq!(Ok(TypedValue::Boolean(false)), TypedValue::Boolean(false).cast_to(DataType::Boolean));
assert_eq!(Ok(TypedValue::Boolean(true)), TypedValue::Integer(123).cast_to(DataType::Boolean));
assert_eq!(Ok(TypedValue::Boolean(false)), TypedValue::Integer(0).cast_to(DataType::Boolean));
assert_eq!(Err(TypedValue::Decimal(0.0)), TypedValue::Decimal(0.0).cast_to(DataType::Boolean));
assert_eq!(Err(TypedValue::Decimal(123.0)), TypedValue::Decimal(123.0).cast_to(DataType::Boolean));
assert_eq!(Ok(TypedValue::Boolean(true)), TypedValue::String("true".into()).cast_to(DataType::Boolean));
assert_eq!(Ok(TypedValue::Boolean(true)), TypedValue::String("1".into()).cast_to(DataType::Boolean));
assert_eq!(Ok(TypedValue::Boolean(true)), TypedValue::String("y".into()).cast_to(DataType::Boolean));
assert_eq!(Ok(TypedValue::Boolean(true)), TypedValue::String("yes".into()).cast_to(DataType::Boolean));
assert_eq!(Ok(TypedValue::Boolean(false)), TypedValue::String("false".into()).cast_to(DataType::Boolean));
assert_eq!(Ok(TypedValue::Boolean(false)), TypedValue::String("0".into()).cast_to(DataType::Boolean));
assert_eq!(Ok(TypedValue::Boolean(false)), TypedValue::String("n".into()).cast_to(DataType::Boolean));
assert_eq!(Ok(TypedValue::Boolean(false)), TypedValue::String("no".into()).cast_to(DataType::Boolean));
assert_eq!(Err(TypedValue::String("blorg".into())), TypedValue::String("blorg".into()).cast_to(DataType::Boolean));
assert_eq!(
Ok(TypedValue::Boolean(true)),
TypedValue::Boolean(true).cast_to(DataType::Boolean)
);
assert_eq!(
Ok(TypedValue::Boolean(false)),
TypedValue::Boolean(false).cast_to(DataType::Boolean)
);
assert_eq!(
Ok(TypedValue::Boolean(true)),
TypedValue::Integer(123).cast_to(DataType::Boolean)
);
assert_eq!(
Ok(TypedValue::Boolean(false)),
TypedValue::Integer(0).cast_to(DataType::Boolean)
);
assert_eq!(
Err(TypedValue::Decimal(0.0)),
TypedValue::Decimal(0.0).cast_to(DataType::Boolean)
);
assert_eq!(
Err(TypedValue::Decimal(123.0)),
TypedValue::Decimal(123.0).cast_to(DataType::Boolean)
);
assert_eq!(
Ok(TypedValue::Boolean(true)),
TypedValue::String("true".into()).cast_to(DataType::Boolean)
);
assert_eq!(
Ok(TypedValue::Boolean(true)),
TypedValue::String("1".into()).cast_to(DataType::Boolean)
);
assert_eq!(
Ok(TypedValue::Boolean(true)),
TypedValue::String("y".into()).cast_to(DataType::Boolean)
);
assert_eq!(
Ok(TypedValue::Boolean(true)),
TypedValue::String("yes".into()).cast_to(DataType::Boolean)
);
assert_eq!(
Ok(TypedValue::Boolean(false)),
TypedValue::String("false".into()).cast_to(DataType::Boolean)
);
assert_eq!(
Ok(TypedValue::Boolean(false)),
TypedValue::String("0".into()).cast_to(DataType::Boolean)
);
assert_eq!(
Ok(TypedValue::Boolean(false)),
TypedValue::String("n".into()).cast_to(DataType::Boolean)
);
assert_eq!(
Ok(TypedValue::Boolean(false)),
TypedValue::String("no".into()).cast_to(DataType::Boolean)
);
assert_eq!(
Err(TypedValue::String("blorg".into())),
TypedValue::String("blorg".into()).cast_to(DataType::Boolean)
);
}
#[test]
fn test_cast_to_int() {
// Cast to bool
assert_eq!(Ok(TypedValue::Integer(1)), TypedValue::Boolean(true).cast_to(DataType::Integer));
assert_eq!(Ok(TypedValue::Integer(0)), TypedValue::Boolean(false).cast_to(DataType::Integer));
assert_eq!(
Ok(TypedValue::Integer(1)),
TypedValue::Boolean(true).cast_to(DataType::Integer)
);
assert_eq!(
Ok(TypedValue::Integer(0)),
TypedValue::Boolean(false).cast_to(DataType::Integer)
);
assert_eq!(Ok(TypedValue::Integer(123)), TypedValue::Integer(123).cast_to(DataType::Integer));
assert_eq!(Ok(TypedValue::Integer(0)), TypedValue::Integer(0).cast_to(DataType::Integer));
assert_eq!(
Ok(TypedValue::Integer(123)),
TypedValue::Integer(123).cast_to(DataType::Integer)
);
assert_eq!(
Ok(TypedValue::Integer(0)),
TypedValue::Integer(0).cast_to(DataType::Integer)
);
assert_eq!(Ok(TypedValue::Integer(0)), TypedValue::Decimal(0.0).cast_to(DataType::Integer));
assert_eq!(Ok(TypedValue::Integer(123)), TypedValue::Decimal(123.0).cast_to(DataType::Integer));
assert_eq!(Ok(TypedValue::Integer(-124)), TypedValue::Decimal(-123.7).cast_to(DataType::Integer));
assert_eq!(
Ok(TypedValue::Integer(0)),
TypedValue::Decimal(0.0).cast_to(DataType::Integer)
);
assert_eq!(
Ok(TypedValue::Integer(123)),
TypedValue::Decimal(123.0).cast_to(DataType::Integer)
);
assert_eq!(
Ok(TypedValue::Integer(-124)),
TypedValue::Decimal(-123.7).cast_to(DataType::Integer)
);
assert_eq!(Ok(TypedValue::Integer(123)), TypedValue::String("123".into()).cast_to(DataType::Integer));
assert_eq!(Ok(TypedValue::Integer(-123)), TypedValue::String("-123".into()).cast_to(DataType::Integer));
assert_eq!(Ok(TypedValue::Integer(0)), TypedValue::String("0".into()).cast_to(DataType::Integer));
assert_eq!(Err(TypedValue::String("123.456".into())), TypedValue::String("123.456".into()).cast_to(DataType::Integer));
assert_eq!(Err(TypedValue::String("-123.456".into())), TypedValue::String("-123.456".into()).cast_to(DataType::Integer));
assert_eq!(
Ok(TypedValue::Integer(123)),
TypedValue::String("123".into()).cast_to(DataType::Integer)
);
assert_eq!(
Ok(TypedValue::Integer(-123)),
TypedValue::String("-123".into()).cast_to(DataType::Integer)
);
assert_eq!(
Ok(TypedValue::Integer(0)),
TypedValue::String("0".into()).cast_to(DataType::Integer)
);
assert_eq!(
Err(TypedValue::String("123.456".into())),
TypedValue::String("123.456".into()).cast_to(DataType::Integer)
);
assert_eq!(
Err(TypedValue::String("-123.456".into())),
TypedValue::String("-123.456".into()).cast_to(DataType::Integer)
);
}
#[test]
fn test_cast_to_decimal() {
// Cast to bool
assert_eq!(Err(TypedValue::Boolean(true)), TypedValue::Boolean(true).cast_to(DataType::Decimal));
assert_eq!(Err(TypedValue::Boolean(false)), TypedValue::Boolean(false).cast_to(DataType::Decimal));
assert_eq!(
Err(TypedValue::Boolean(true)),
TypedValue::Boolean(true).cast_to(DataType::Decimal)
);
assert_eq!(
Err(TypedValue::Boolean(false)),
TypedValue::Boolean(false).cast_to(DataType::Decimal)
);
assert_eq!(Ok(TypedValue::Decimal(123.0)), TypedValue::Integer(123).cast_to(DataType::Decimal));
assert_eq!(Ok(TypedValue::Decimal(0.0)), TypedValue::Integer(0).cast_to(DataType::Decimal));
assert_eq!(
Ok(TypedValue::Decimal(123.0)),
TypedValue::Integer(123).cast_to(DataType::Decimal)
);
assert_eq!(
Ok(TypedValue::Decimal(0.0)),
TypedValue::Integer(0).cast_to(DataType::Decimal)
);
assert_eq!(Ok(TypedValue::Decimal(0.0)), TypedValue::Decimal(0.0).cast_to(DataType::Decimal));
assert_eq!(Ok(TypedValue::Decimal(-123.7)), TypedValue::Decimal(-123.7).cast_to(DataType::Decimal));
assert_eq!(
Ok(TypedValue::Decimal(0.0)),
TypedValue::Decimal(0.0).cast_to(DataType::Decimal)
);
assert_eq!(
Ok(TypedValue::Decimal(-123.7)),
TypedValue::Decimal(-123.7).cast_to(DataType::Decimal)
);
assert_eq!(Ok(TypedValue::Decimal(123.0)), TypedValue::String("123".into()).cast_to(DataType::Decimal));
assert_eq!(Ok(TypedValue::Decimal(-123.0)), TypedValue::String("-123".into()).cast_to(DataType::Decimal));
assert_eq!(Ok(TypedValue::Decimal(0.0)), TypedValue::String("0".into()).cast_to(DataType::Decimal));
assert_eq!(Ok(TypedValue::Decimal(-123.456)), TypedValue::String("-123.456".into()).cast_to(DataType::Decimal));
assert_eq!(
Ok(TypedValue::Decimal(123.0)),
TypedValue::String("123".into()).cast_to(DataType::Decimal)
);
assert_eq!(
Ok(TypedValue::Decimal(-123.0)),
TypedValue::String("-123".into()).cast_to(DataType::Decimal)
);
assert_eq!(
Ok(TypedValue::Decimal(0.0)),
TypedValue::String("0".into()).cast_to(DataType::Decimal)
);
assert_eq!(
Ok(TypedValue::Decimal(-123.456)),
TypedValue::String("-123.456".into()).cast_to(DataType::Decimal)
);
}
#[test]
fn test_cast_to_string() {
// Cast to bool
assert_eq!(Ok(TypedValue::String("1".into())), TypedValue::Boolean(true).cast_to(DataType::String));
assert_eq!(Ok(TypedValue::String("0".into())), TypedValue::Boolean(false).cast_to(DataType::String));
assert_eq!(
Ok(TypedValue::String("1".into())),
TypedValue::Boolean(true).cast_to(DataType::String)
);
assert_eq!(
Ok(TypedValue::String("0".into())),
TypedValue::Boolean(false).cast_to(DataType::String)
);
assert_eq!(Ok(TypedValue::String("123".into())), TypedValue::Integer(123).cast_to(DataType::String));
assert_eq!(Ok(TypedValue::String("0".into())), TypedValue::Integer(0).cast_to(DataType::String));
assert_eq!(
Ok(TypedValue::String("123".into())),
TypedValue::Integer(123).cast_to(DataType::String)
);
assert_eq!(
Ok(TypedValue::String("0".into())),
TypedValue::Integer(0).cast_to(DataType::String)
);
assert_eq!(Ok(TypedValue::String("0".into())), TypedValue::Decimal(0.0).cast_to(DataType::String));
assert_eq!(Ok(TypedValue::String("123".into())), TypedValue::Decimal(123.0).cast_to(DataType::String));
assert_eq!(Ok(TypedValue::String("-123.5".into())), TypedValue::Decimal(-123.5).cast_to(DataType::String));
assert_eq!(
Ok(TypedValue::String("0".into())),
TypedValue::Decimal(0.0).cast_to(DataType::String)
);
assert_eq!(
Ok(TypedValue::String("123".into())),
TypedValue::Decimal(123.0).cast_to(DataType::String)
);
assert_eq!(
Ok(TypedValue::String("-123.5".into())),
TypedValue::Decimal(-123.5).cast_to(DataType::String)
);
assert_eq!(Ok(TypedValue::String("blorg".into())), TypedValue::String("blorg".into()).cast_to(DataType::String));
assert_eq!(
Ok(TypedValue::String("blorg".into())),
TypedValue::String("blorg".into()).cast_to(DataType::String)
);
}
}
@ -177,7 +310,7 @@ pub struct Object {
/// Object template ID
pub model: ID,
/// Model name, mainly shown in lists
pub name : String,
pub name: String,
}
/// Relation between two objects

6
yopa/src/id.rs
Unescape View File

@ -42,10 +42,10 @@ mod impl_u64 {
}
}
#[cfg(feature = "uuid-ids")]
pub use impl_uuid::{ID, next_id, zero_id};
#[cfg(not(feature = "uuid-ids"))]
pub use impl_u64::{ID, next_id, zero_id};
pub use impl_u64::{next_id, zero_id, ID};
#[cfg(feature = "uuid-ids")]
pub use impl_uuid::{next_id, zero_id, ID};
/// Something that has ID
pub trait HaveId {

10
yopa/src/insert.rs
Unescape View File

@ -43,13 +43,18 @@ impl InsertRel {
#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct InsertObj {
pub model: ID,
pub name : String,
pub name: String,
pub values: Vec<InsertValue>,
pub relations: Vec<InsertRel>,
}
impl InsertObj {
pub fn new(model_id: ID, name : String, values: Vec<InsertValue>, relations: Vec<InsertRel>) -> Self {
pub fn new(
model_id: ID,
name: String,
values: Vec<InsertValue>,
relations: Vec<InsertRel>,
) -> Self {
Self {
model: model_id,
name,
@ -58,4 +63,3 @@ impl InsertObj {
}
}
}

528
yopa/src/lib.rs
Unescape View File

@ -1,36 +1,38 @@
#[macro_use] extern crate serde_json;
#[macro_use] extern crate log;
#[macro_use]
extern crate serde_json;
#[macro_use]
extern crate log;
use std::borrow::Cow;
use std::collections::{HashMap};
use std::collections::HashMap;
use itertools::Itertools;
use serde::{Deserialize, Serialize};
use thiserror::Error;
use cool::{KVVecToKeysOrValues, map_drain_filter};
pub use id::ID;
use crate::model::{PropertyModel, RelationModel};
use cool::{map_drain_filter, KVVecToKeysOrValues};
use id::next_id;
pub use id::ID;
use insert::InsertObj;
use insert::InsertValue;
use model::ObjectModel;
use crate::model::{PropertyModel, RelationModel};
pub use data::{TypedValue};
pub use model::{DataType};
use crate::data::{Object};
use crate::data::Object;
use crate::update::{UpdateObj, UpsertValue};
pub use data::TypedValue;
pub use model::DataType;
pub mod model;
mod cool;
pub mod data;
pub mod id;
pub mod insert;
pub mod model;
pub mod update;
pub mod id;
mod cool;
mod serde_map_as_list;
#[cfg(test)]
mod tests;
mod serde_map_as_list;
/// Stupid storage with no persistence
#[derive(Debug, Default, Serialize, Deserialize, Clone)]
@ -50,7 +52,6 @@ pub struct Storage {
values: HashMap<ID, data::Value>,
}
#[derive(Debug, Error)]
pub enum StorageError {
#[error("Referenced {0} does not exist")]
@ -68,11 +69,20 @@ impl Storage {
/// Define a data object
pub fn define_object(&mut self, mut tpl: model::ObjectModel) -> Result<ID, StorageError> {
if tpl.name.is_empty() {
return Err(StorageError::ConstraintViolation("Name must not be empty".into()));
return Err(StorageError::ConstraintViolation(
"Name must not be empty".into(),
));
}
if self.obj_models.iter().find(|(_, t)| t.name == tpl.name).is_some() {
return Err(StorageError::ConstraintViolation(format!("Object model with the name \"{}\" already exists", tpl.name).into()));
if self
.obj_models
.iter()
.find(|(_, t)| t.name == tpl.name)
.is_some()
{
return Err(StorageError::ConstraintViolation(
format!("Object model with the name \"{}\" already exists", tpl.name).into(),
));
}
debug!("Define object model \"{}\"", tpl.name);
@ -85,31 +95,45 @@ impl Storage {
/// Define a relation between two data objects
pub fn define_relation(&mut self, mut rel: model::RelationModel) -> Result<ID, StorageError> {
if rel.name.is_empty() || rel.reciprocal_name.is_empty() {
return Err(StorageError::ConstraintViolation("Names must not be empty".into()));
return Err(StorageError::ConstraintViolation(
"Names must not be empty".into(),
));
}
if !self.obj_models.contains_key(&rel.object) {
return Err(StorageError::NotExist(format!("Source object model {}", rel.object).into()));
return Err(StorageError::NotExist(
format!("Source object model {}", rel.object).into(),
));
}
if !self.obj_models.contains_key(&rel.related) {
return Err(StorageError::NotExist(format!("Related object model {}", rel.related).into()));
return Err(StorageError::NotExist(
format!("Related object model {}", rel.related).into(),
));
}
if let Some((_, colliding)) = self.rel_models.iter().find(|(_, other)| {
(other.name == rel.name && other.object == rel.object) // Exact match
|| (other.name == rel.reciprocal_name && other.object == rel.related) // Our reciprocal name collides with related's own relation name
|| (other.reciprocal_name == rel.name && other.related == rel.object) // Our name name collides with a reciprocal name on the other relation
|| (other.reciprocal_name == rel.reciprocal_name && other.related == rel.related) // Reciprocal names collide for the same destination
|| (other.reciprocal_name == rel.reciprocal_name && other.related == rel.related)
// Reciprocal names collide for the same destination
}) {
return Err(StorageError::ConstraintViolation(
format!("Name collision (\"{}\" / \"{}\") with existing relation (\"{}\" / \"{}\")",
rel.name, rel.reciprocal_name,
colliding.name, colliding.reciprocal_name
).into()));
format!(
"Name collision (\"{}\" / \"{}\") with existing relation (\"{}\" / \"{}\")",
rel.name, rel.reciprocal_name, colliding.name, colliding.reciprocal_name
)
.into(),
));
}
debug!("Define relation model \"{}\" from {} to {}, reciprocal name \"{}\"",
rel.name, self.describe_model(rel.object), self.describe_model(rel.related), rel.reciprocal_name);
debug!(
"Define relation model \"{}\" from {} to {}, reciprocal name \"{}\"",
rel.name,
self.describe_model(rel.object),
self.describe_model(rel.related),
rel.reciprocal_name
);
let id = next_id();
rel.id = id;
@ -120,28 +144,51 @@ impl Storage {
/// Define a property attached to an object or a relation
pub fn define_property(&mut self, mut prop: model::PropertyModel) -> Result<ID, StorageError> {
if prop.name.is_empty() {
return Err(StorageError::ConstraintViolation("Name must not be empty".into()));
return Err(StorageError::ConstraintViolation(
"Name must not be empty".into(),
));
}
if !self.obj_models.contains_key(&prop.object) {
// Maybe it's attached to a relation?
if !self.rel_models.contains_key(&prop.object) {
return Err(StorageError::NotExist(format!("Object or relation model {}", prop.object).into()));
return Err(StorageError::NotExist(
format!("Object or relation model {}", prop.object).into(),
));
}
}
if self.prop_models.iter().find(|(_, t)| t.object == prop.object && t.name == prop.name).is_some() {
if self
.prop_models
.iter()
.find(|(_, t)| t.object == prop.object && t.name == prop.name)
.is_some()
{
return Err(StorageError::ConstraintViolation(
format!("Property with the name \"{}\" already exists on model {}", prop.name, self.describe_model(prop.object)).into()));
format!(
"Property with the name \"{}\" already exists on model {}",
prop.name,
self.describe_model(prop.object)
)
.into(),
));
}
// Ensure the default type is compatible
prop.default = match prop.default.clone().cast_to(prop.data_type) {
Ok(v) => v,
Err(_) => return Err(StorageError::NotExist(format!("default value {:?} has invalid type", prop.default).into()))
Err(_) => {
return Err(StorageError::NotExist(
format!("default value {:?} has invalid type", prop.default).into(),
))
}
};
debug!("Define property model \"{}\" of {}", prop.name, self.describe_model(prop.object));
debug!(
"Define property model \"{}\" of {}",
prop.name,
self.describe_model(prop.object)
);
let id = next_id();
prop.id = id;
self.prop_models.insert(id, prop);
@ -153,13 +200,17 @@ impl Storage {
return if let Some(t) = self.obj_models.remove(&id) {
debug!("Undefine object model \"{}\"", t.name);
// Remove relation templates
let removed_relation_ids = map_drain_filter(&mut self.rel_models, |_k, v| v.object == id || v.related == id)
.keys();
let removed_relation_ids = map_drain_filter(&mut self.rel_models, |_k, v| {
v.object == id || v.related == id
})
.keys();
debug!("Undefined {} relation models", removed_relation_ids.len());
// Remove related property templates
let removed_prop_ids = map_drain_filter(&mut self.prop_models, |_k, v| v.object == id || removed_relation_ids.contains(&v.object))
.keys();
let removed_prop_ids = map_drain_filter(&mut self.prop_models, |_k, v| {
v.object == id || removed_relation_ids.contains(&v.object)
})
.keys();
debug!("Undefined {} property models", removed_prop_ids.len());
// Remove objects
@ -167,18 +218,24 @@ impl Storage {
debug!("Deleted {} objects", removed_objects.len());
// Remove property values
let removed_values = map_drain_filter(&mut self.values, |_k, v| removed_prop_ids.contains(&v.model));
let removed_values = map_drain_filter(&mut self.values, |_k, v| {
removed_prop_ids.contains(&v.model)
});
debug!("Deleted {} object or relation values", removed_values.len());
// Remove relations
let removed_relations = map_drain_filter(&mut self.relations, |_k, v| removed_relation_ids.contains(&v.model));
let removed_relations = map_drain_filter(&mut self.relations, |_k, v| {
removed_relation_ids.contains(&v.model)
});
debug!("Deleted {} object relations", removed_relations.len());
// Related object remain untouched, so there can be a problem with orphans. This is up to the application to deal with.
Ok(t)
} else {
Err(StorageError::NotExist(format!("object model {}", id).into()))
Err(StorageError::NotExist(
format!("object model {}", id).into(),
))
};
}
@ -192,17 +249,25 @@ impl Storage {
debug!("Deleted {} object relations", removed.len());
// Remove related property templates
let removed_prop_tpl_ids = map_drain_filter(&mut self.prop_models, |_k, v| v.object == id).keys();
debug!("Undefined {} relation property models", removed_prop_tpl_ids.len());
let removed_values = map_drain_filter(&mut self.values, |_k, v| removed_prop_tpl_ids.contains(&v.model));
let removed_prop_tpl_ids =
map_drain_filter(&mut self.prop_models, |_k, v| v.object == id).keys();
debug!(
"Undefined {} relation property models",
removed_prop_tpl_ids.len()
);
let removed_values = map_drain_filter(&mut self.values, |_k, v| {
removed_prop_tpl_ids.contains(&v.model)
});
debug!("Deleted {} relation values", removed_values.len());
// Related object remain untouched, so there can be a problem with orphans. This is up to the application to deal with.
Ok(t)
} else {
Err(StorageError::NotExist(format!("relation model {}", id).into()))
Err(StorageError::NotExist(
format!("relation model {}", id).into(),
))
};
}
@ -216,7 +281,9 @@ impl Storage {
debug!("Deleted {} values", removed_values.len());
Ok(t)
} else {
Err(StorageError::NotExist(format!("property model {}", id).into()))
Err(StorageError::NotExist(
format!("property model {}", id).into(),
))
};
}
@ -253,38 +320,70 @@ impl Storage {
let obj_model = match self.obj_models.get(&obj_model_id) {
Some(m) => m,
None => return Err(StorageError::NotExist(format!("object model {}", obj_model_id).into()))
None => {
return Err(StorageError::NotExist(
format!("object model {}", obj_model_id).into(),
))
}
};
// validate unique name
if self.objects.iter().find(|(_, o)| o.model == obj_model_id && o.name == insobj.name).is_some() {
if self
.objects
.iter()
.find(|(_, o)| o.model == obj_model_id && o.name == insobj.name)
.is_some()
{
return Err(StorageError::ConstraintViolation(
format!("{} named \"{}\" already exists", self.get_model_name(obj_model_id), insobj.name).into()));
format!(
"{} named \"{}\" already exists",
self.get_model_name(obj_model_id),
insobj.name
)
.into(),
));
}
let object_id = next_id();
let object = data::Object {
id: object_id,
model: obj_model_id,
name: insobj.name
name: insobj.name,
};
let find_values_to_insert = |values: Vec<InsertValue>, parent_id : ID, parent_model_id: ID| -> Result<Vec<data::Value>, StorageError> {
let find_values_to_insert = |values: Vec<InsertValue>,
parent_id: ID,
parent_model_id: ID|
-> Result<Vec<data::Value>, StorageError> {
let mut values_by_id = values.into_iter().into_group_map_by(|iv| iv.model);
let mut values_to_insert = vec![];
for (id, prop) in self.prop_models.iter().filter(|(_id, p)| p.object == parent_model_id) {
for (id, prop) in self
.prop_models
.iter()
.filter(|(_id, p)| p.object == parent_model_id)
{
if let Some(values) = values_by_id.remove(id) {
if values.len() > 1 && !prop.multiple {
return Err(StorageError::ConstraintViolation(format!("{} of {} cannot have multiple values", prop, self.describe_model(parent_model_id)).into()));
return Err(StorageError::ConstraintViolation(
format!(
"{} of {} cannot have multiple values",
prop,
self.describe_model(parent_model_id)
)
.into(),
));
}
for val_instance in values {
values_to_insert.push(data::Value {
id: next_id(),
object: parent_id,
model: prop.id,
value: val_instance.value.cast_to(prop.data_type)
.map_err(|v| StorageError::ConstraintViolation(format!("{} cannot accept value {:?}", prop, v).into()))?,
value: val_instance.value.cast_to(prop.data_type).map_err(|v| {
StorageError::ConstraintViolation(
format!("{} cannot accept value {:?}", prop, v).into(),
)
})?,
});
}
} else {
@ -305,30 +404,49 @@ impl Storage {
let mut values_to_insert = find_values_to_insert(insobj.values, object_id, obj_model_id)?;
// And now ..... relations!
let mut relations_by_id = insobj.relations.into_iter().into_group_map_by(|ir| ir.model);
let mut relations_by_id = insobj
.relations
.into_iter()
.into_group_map_by(|ir| ir.model);
let mut relations_to_insert = vec![];
for (relation_model_id, relation_model) in self.rel_models.iter().filter(|(_id, r)| r.object == obj_model_id) {
for (relation_model_id, relation_model) in self
.rel_models
.iter()
.filter(|(_id, r)| r.object == obj_model_id)
{
if let Some(instances) = relations_by_id.remove(relation_model_id) {
if instances.len() > 1 && !relation_model.multiple {
return Err(StorageError::ConstraintViolation(format!("{} of {} cannot be set multiply", relation_model, obj_model).into()));
return Err(StorageError::ConstraintViolation(
format!("{} of {} cannot be set multiply", relation_model, obj_model)
.into(),
));
}
for rel_instance in instances {
if let Some(related) = self.objects.get(&rel_instance.related) {
if related.model != relation_model.related {
return Err(StorageError::ConstraintViolation(
format!("{} of {} requires object of type {}, got {}",
relation_model, obj_model,
self.describe_model(relation_model.related),
self.describe_model(related.model)).into()));
format!(
"{} of {} requires object of type {}, got {}",
relation_model,
obj_model,
self.describe_model(relation_model.related),
self.describe_model(related.model)
)
.into(),
));
}
}
let relation_id = next_id();
// Relations can have properties
values_to_insert.extend(find_values_to_insert(rel_instance.values, relation_id, *relation_model_id)?);
values_to_insert.extend(find_values_to_insert(
rel_instance.values,
relation_id,
*relation_model_id,
)?);
relations_to_insert.push(data::Relation {
id: relation_id,
@ -339,7 +457,9 @@ impl Storage {
}
} else {
if !relation_model.optional {
return Err(StorageError::ConstraintViolation(format!("{} is required for {}", relation_model, obj_model).into()));
return Err(StorageError::ConstraintViolation(
format!("{} is required for {}", relation_model, obj_model).into(),
));
}
}
}
@ -360,92 +480,120 @@ impl Storage {
}
// Reading
pub fn get_object_models(&self) -> impl Iterator<Item=&ObjectModel> {
pub fn get_object_models(&self) -> impl Iterator<Item = &ObjectModel> {
self.obj_models.values()
}
pub fn get_object_model(&self, id : ID) -> Option<&ObjectModel> {
pub fn get_object_model(&self, id: ID) -> Option<&ObjectModel> {
self.obj_models.get(&id)
}
pub fn get_relation_model(&self, id : ID) -> Option<&RelationModel> {
pub fn get_relation_model(&self, id: ID) -> Option<&RelationModel> {
self.rel_models.get(&id)
}
pub fn get_property_model(&self, id : ID) -> Option<&PropertyModel> {
pub fn get_property_model(&self, id: ID) -> Option<&PropertyModel> {
self.prop_models.get(&id)
}
pub fn get_grouped_prop_models(&self) -> HashMap<ID, Vec<&PropertyModel>> {
self.prop_models.values()
self.prop_models
.values()
.into_group_map_by(|model| model.object)
}
pub fn get_grouped_prop_models_for_parents(&self, parents: Vec<ID>) -> HashMap<ID, Vec<&PropertyModel>> {
self.prop_models.values()
pub fn get_grouped_prop_models_for_parents(
&self,
parents: Vec<ID>,
) -> HashMap<ID, Vec<&PropertyModel>> {
self.prop_models
.values()
.filter(|p| parents.contains(&p.object))
.into_group_map_by(|model| model.object)
}
pub fn get_relations_for_object(&self, object_id: ID) -> impl Iterator<Item=&data::Relation> {
self.relations.values()
pub fn get_relations_for_object(&self, object_id: ID) -> impl Iterator<Item = &data::Relation> {
self.relations
.values()
.filter(move |rel| rel.object == object_id)
}
pub fn get_reciprocal_relations_for_object(&self, object_id: ID) -> impl Iterator<Item=&data::Relation> {
self.relations.values()
pub fn get_reciprocal_relations_for_object(
&self,
object_id: ID,
) -> impl Iterator<Item = &data::Relation> {
self.relations
.values()
.filter(move |rel| rel.related == object_id)
}
pub fn get_values_for_object(&self, object_id: ID) -> impl Iterator<Item=&data::Value> {
self.values.values()
pub fn get_values_for_object(&self, object_id: ID) -> impl Iterator<Item = &data::Value> {
self.values
.values()
.filter(move |prop| prop.object == object_id)
}
pub fn get_grouped_values_for_objects(&self, parents: Vec<ID>) -> HashMap<ID, Vec<&data::Value>> {
self.values.values()
pub fn get_grouped_values_for_objects(
&self,
parents: Vec<ID>,
) -> HashMap<ID, Vec<&data::Value>> {
self.values
.values()
.filter(move |prop| parents.contains(&prop.object))
.into_group_map_by(|model| model.object)
}
pub fn get_relation_models_for_object_model(&self, model_id: ID) -> impl Iterator<Item=&RelationModel> {
self.rel_models.values()
pub fn get_relation_models_for_object_model(
&self,
model_id: ID,
) -> impl Iterator<Item = &RelationModel> {
self.rel_models
.values()
.filter(move |model| model.object == model_id)
}
pub fn get_property_models_for_parents(&self, parents: Vec<ID>) -> impl Iterator<Item=&PropertyModel> {
self.prop_models.values()
pub fn get_property_models_for_parents(
&self,
parents: Vec<ID>,
) -> impl Iterator<Item = &PropertyModel> {
self.prop_models
.values()
.filter(move |model| parents.contains(&model.object))
}
pub fn get_objects_of_type(&self, model_ids : Vec<ID>) -> impl Iterator<Item=&data::Object> {
self.objects.values()
pub fn get_objects_of_type(&self, model_ids: Vec<ID>) -> impl Iterator<Item = &data::Object> {
self.objects
.values()
.filter(move |object| model_ids.contains(&object.model))
}
pub fn get_grouped_objects(&self) -> HashMap<ID, Vec<&Object>> {
self.objects.values()
self.objects
.values()
.into_group_map_by(|object| object.model)
}
pub fn get_grouped_relation_models(&self) -> HashMap<ID, Vec<&RelationModel>> {
self.rel_models.values()
self.rel_models
.values()
.into_group_map_by(|model| model.object)
}
pub fn get_grouped_reciprocal_relation_models(&self) -> HashMap<ID, Vec<&RelationModel>> {
self.rel_models.values()
self.rel_models
.values()
.into_group_map_by(|model| model.related)
}
pub fn get_object(&self, id : ID) -> Option<&Object> {
pub fn get_object(&self, id: ID) -> Option<&Object> {
self.objects.get(&id)
}
// Updates
pub fn update_object(&mut self, updobj: UpdateObj) -> Result<(), StorageError> {
let old_object = self.objects.get(&updobj.id)
.ok_or_else(|| StorageError::ConstraintViolation(format!("Object does not exist").into()))?;
let old_object = self.objects.get(&updobj.id).ok_or_else(|| {
StorageError::ConstraintViolation(format!("Object does not exist").into())
})?;
let updated_object_id = old_object.id;
let updated_object_model_id = old_object.model;
@ -453,48 +601,92 @@ impl Storage {
let obj_model = match self.obj_models.get(&updated_object_model_id) {
Some(m) => m,
None => return Err(StorageError::NotExist(format!("object model {}", updated_object_model_id).into()))
None => {
return Err(StorageError::NotExist(
format!("object model {}", updated_object_model_id).into(),
))
}
};
// validate unique name
if self.objects.iter().find(|(_, o)| o.model == updated_object_model_id && o.name == updobj.name && o.id != updated_object_id).is_some() {
if self
.objects
.iter()
.find(|(_, o)| {
o.model == updated_object_model_id
&& o.name == updobj.name
&& o.id != updated_object_id
})
.is_some()
{
return Err(StorageError::ConstraintViolation(
format!("{} named \"{}\" already exists", self.get_model_name(updated_object_model_id), updobj.name).into()));
format!(
"{} named \"{}\" already exists",
self.get_model_name(updated_object_model_id),
updobj.name
)
.into(),
));
}
// Update the object after everything else is checked
let find_values_to_change = |values: Vec<UpsertValue>, parent_id : ID, parent_model_id: ID| -> Result<(
// Insert (can overwrite existing, the ID will not change)
Vec<data::Value>,
// Delete
Vec<ID>
), StorageError> {
let find_values_to_change = |values: Vec<UpsertValue>,
parent_id: ID,
parent_model_id: ID|
-> Result<
(
// Insert (can overwrite existing, the ID will not change)
Vec<data::Value>,
// Delete
Vec<ID>,
),
StorageError,
> {
let mut values_by_model = values.into_iter().into_group_map_by(|iv| iv.model);
let mut values_to_insert = vec![];
let mut ids_to_delete = vec![];
let mut existing_values_by_id = self.values.values()
let mut existing_values_by_id = self
.values
.values()
.filter(|v| v.object == parent_id)
.into_group_map_by(|v| v.model);
for (prop_model_id, prop) in self.prop_models.iter().filter(|(_id, p)| p.object == parent_model_id) {
for (prop_model_id, prop) in self
.prop_models
.iter()
.filter(|(_id, p)| p.object == parent_model_id)
{
if let Some(values) = values_by_model.remove(prop_model_id) {
if values.len() > 1 && !prop.multiple {
return Err(StorageError::ConstraintViolation(format!("{} of {} cannot have multiple values", prop, self.describe_model(parent_model_id)).into()));
return Err(StorageError::ConstraintViolation(
format!(
"{} of {} cannot have multiple values",
prop,
self.describe_model(parent_model_id)
)
.into(),
));
}
let updated_ids = values.iter().filter_map(|v| v.id).collect_vec();
ids_to_delete.extend(existing_values_by_id.remove(&prop.id).unwrap_or_default().into_iter()
.filter(|v| !updated_ids.contains(&v.id)).map(|v| v.id));
ids_to_delete.extend(
existing_values_by_id
.remove(&prop.id)
.unwrap_or_default()
.into_iter()
.filter(|v| !updated_ids.contains(&v.id))
.map(|v| v.id),
);
for val_instance in values {
values_to_insert.push(data::Value {
id: val_instance.id.unwrap_or_else(|| next_id()),
object: parent_id,
model: prop.id,
value: val_instance.value
value: val_instance.value,
});
}
} else {
@ -511,42 +703,63 @@ impl Storage {
Ok((values_to_insert, ids_to_delete))
};
let (mut values_to_insert, mut value_ids_to_delete) = find_values_to_change(updobj.values, updated_object_id, updated_object_model_id)?;
let (mut values_to_insert, mut value_ids_to_delete) =
find_values_to_change(updobj.values, updated_object_id, updated_object_model_id)?;
// And now ..... relations!
let mut relations_by_model = updobj.relations.into_iter().into_group_map_by(|ir| ir.model);
let mut relations_by_model = updobj
.relations
.into_iter()
.into_group_map_by(|ir| ir.model);
let mut relations_to_insert = vec![];
let mut relations_to_delete = vec![];
let mut existing_relations_by_id = self.relations.values()
let mut existing_relations_by_id = self
.relations
.values()
.filter(|v| v.object == updated_object_id)
.into_group_map_by(|v| v.model);
let rel_models_by_id = self.rel_models.iter().filter(|(_id, r)| r.object == updated_object_model_id);
let rel_models_by_id = self
.rel_models
.iter()
.filter(|(_id, r)| r.object == updated_object_model_id);
for (relation_model_id, relation_model) in rel_models_by_id {
let mut updated_ids = vec![];
if let Some(instances) = relations_by_model.remove(relation_model_id) {
if instances.len() > 1 && !relation_model.multiple {
return Err(StorageError::ConstraintViolation(format!("{} of {} cannot be set multiply", relation_model, obj_model).into()));
return Err(StorageError::ConstraintViolation(
format!("{} of {} cannot be set multiply", relation_model, obj_model)
.into(),
));
}
for rel_instance in instances {
if let Some(related) = self.objects.get(&rel_instance.related) {
if related.model != relation_model.related {
return Err(StorageError::ConstraintViolation(
format!("{} of {} requires object of type {}, got {}",
relation_model, obj_model,
self.describe_model(relation_model.related),
self.describe_model(related.model)).into()));
format!(
"{} of {} requires object of type {}, got {}",
relation_model,
obj_model,
self.describe_model(relation_model.related),
self.describe_model(related.model)
)
.into(),
));
}
}
let relation_id = rel_instance.id.unwrap_or_else(|| next_id());
// Relations can have properties
let (ins, del) = find_values_to_change(rel_instance.values, relation_id, *relation_model_id)?;
let (ins, del) = find_values_to_change(
rel_instance.values,
relation_id,
*relation_model_id,
)?;
values_to_insert.extend(ins);
value_ids_to_delete.extend(del);
@ -561,12 +774,20 @@ impl Storage {
}
} else {
if !relation_model.optional {
return Err(StorageError::ConstraintViolation(format!("{} is required for {}", relation_model, obj_model).into()));
return Err(StorageError::ConstraintViolation(
format!("{} is required for {}", relation_model, obj_model).into(),
));
}
}
relations_to_delete.extend(existing_relations_by_id.remove(&relation_model_id).unwrap_or_default().into_iter()
.filter(|rel| !updated_ids.contains(&rel.id)).map(|rel| rel.id));
relations_to_delete.extend(
existing_relations_by_id
.remove(&relation_model_id)
.unwrap_or_default()
.into_iter()
.filter(|rel| !updated_ids.contains(&rel.id))
.map(|rel| rel.id),
);
}
let obj_mut = self.objects.get_mut(&updated_object_id).unwrap();
@ -595,26 +816,38 @@ impl Storage {
Ok(())
}
pub fn update_object_model(&mut self, model : ObjectModel) -> Result<(), StorageError> {
pub fn update_object_model(&mut self, model: ObjectModel) -> Result<(), StorageError> {
if model.name.is_empty() {
return Err(StorageError::ConstraintViolation(format!("Model name must not be empty.").into()));
return Err(StorageError::ConstraintViolation(
format!("Model name must not be empty.").into(),
));
}
if !self.obj_models.contains_key(&model.id) {
return Err(StorageError::NotExist(format!("Object model ID {} does not exist.", model.id).into()));
return Err(StorageError::NotExist(
format!("Object model ID {} does not exist.", model.id).into(),
));
}
if let Some(conflict) = self.obj_models.values().find(|m| m.id != model.id && m.name == model.name) {
return Err(StorageError::ConstraintViolation(format!("Object {} already has the name {}", conflict.id, model.name).into()));
if let Some(conflict) = self
.obj_models
.values()
.find(|m| m.id != model.id && m.name == model.name)
{
return Err(StorageError::ConstraintViolation(
format!("Object {} already has the name {}", conflict.id, model.name).into(),
));
}
self.obj_models.insert(model.id, model);
Ok(())
}
pub fn update_relation_model(&mut self, mut rel : RelationModel) -> Result<(), StorageError> {
pub fn update_relation_model(&mut self, mut rel: RelationModel) -> Result<(), StorageError> {
if rel.name.is_empty() || rel.reciprocal_name.is_empty() {
return Err(StorageError::ConstraintViolation(format!("Relation names must not be empty.").into()));
return Err(StorageError::ConstraintViolation(
format!("Relation names must not be empty.").into(),
));
}
// Object and Related can't be changed, so we re-fill them from the existing model
@ -622,7 +855,9 @@ impl Storage {
rel.object = existing.object;
rel.related = existing.related;
} else {
return Err(StorageError::NotExist(format!("Relation model ID {} does not exist.", rel.id).into()));
return Err(StorageError::NotExist(
format!("Relation model ID {} does not exist.", rel.id).into(),
));
}
// Difficult checks ...
@ -647,25 +882,44 @@ impl Storage {
pub fn update_property_model(&mut self, mut prop: PropertyModel) -> Result<(), StorageError> {
if prop.name.is_empty() {
return Err(StorageError::ConstraintViolation(format!("Property name must not be empty.").into()));
return Err(StorageError::ConstraintViolation(
format!("Property name must not be empty.").into(),
));
}
// Object can't be changed, so we re-fill them from the existing model
if let Some(existing) = self.prop_models.get(&prop.id) {
prop.object = existing.object;
} else {
return Err(StorageError::NotExist(format!("Property model ID {} does not exist.", prop.id).into()));
return Err(StorageError::NotExist(
format!("Property model ID {} does not exist.", prop.id).into(),
));
}
if self.prop_models.iter().find(|(_, t)| t.object == prop.object && t.name == prop.name && t.id != prop.id).is_some() {
if self
.prop_models
.iter()
.find(|(_, t)| t.object == prop.object && t.name == prop.name && t.id != prop.id)
.is_some()
{
return Err(StorageError::ConstraintViolation(
format!("property with the name \"{}\" already exists on {}", prop.name, self.describe_model(prop.object)).into()));
format!(
"property with the name \"{}\" already exists on {}",
prop.name,
self.describe_model(prop.object)
)
.into(),
));
}
// Ensure the default type is compatible
prop.default = match prop.default.clone().cast_to(prop.data_type) {
Ok(v) => v,
Err(_) => return Err(StorageError::NotExist(format!("default value {:?} has invalid type", prop.default).into()))
Err(_) => {
return Err(StorageError::NotExist(
format!("default value {:?} has invalid type", prop.default).into(),
))
}
};
self.prop_models.insert(prop.id, prop);
@ -677,12 +931,16 @@ impl Storage {
return if let Some(t) = self.objects.remove(&id) {
debug!("Delete object \"{}\"", t.name);
// Remove relation templates
let removed_relation_ids = map_drain_filter(&mut self.relations, |_k, v| v.object == id || v.related == id)
.keys();
let removed_relation_ids = map_drain_filter(&mut self.relations, |_k, v| {
v.object == id || v.related == id
})
.keys();
debug!("Deleted {} object relations", removed_relation_ids.len());
// Remove values
let removed_values = map_drain_filter(&mut self.values, |_k, v| removed_relation_ids.contains(&v.object) || v.object == id);
let removed_values = map_drain_filter(&mut self.values, |_k, v| {
removed_relation_ids.contains(&v.object) || v.object == id
});
debug!("Deleted {} object values", removed_values.len());
Ok(t)

2
yopa/src/model.rs
Unescape View File

@ -1,7 +1,7 @@
//! Data model structs and enums
use std::fmt::{Display, Formatter};
use std::fmt;
use std::fmt::{Display, Formatter};
use serde::{Deserialize, Serialize};

26
yopa/src/serde_map_as_list.rs
Unescape View File

@ -1,19 +1,19 @@
//! Serialize a HashMap of ID-keyed structs that also contain the ID inside
//! to a plain list, and also back when deserializing.
use std::collections::HashMap;
use crate::id::HaveId;
use crate::ID;
use serde::{Serialize, Deserializer, Deserialize};
use serde::de::{SeqAccess, Visitor};
use serde::ser::SerializeSeq;
use serde::de::{Visitor, SeqAccess};
use serde::{Deserialize, Deserializer, Serialize};
use std::collections::HashMap;
use std::fmt;
use crate::id::HaveId;
use std::marker::PhantomData;
pub fn serialize<S, X>(x: &HashMap<ID, X>, s: S) -> Result<S::Ok, S::Error>
where
S: serde::Serializer,
X: Serialize + HaveId
where
S: serde::Serializer,
X: Serialize + HaveId,
{
let mut seq = s.serialize_seq(Some(x.len()))?;
for p in x.values() {
@ -23,16 +23,16 @@ pub fn serialize<S, X>(x: &HashMap<ID, X>, s: S) -> Result<S::Ok, S::Error>
}
pub fn deserialize<'de, D, X>(deserializer: D) -> Result<HashMap<ID, X>, D::Error>
where
D: Deserializer<'de>,
X: Deserialize<'de> + HaveId
where
D: Deserializer<'de>,
X: Deserialize<'de> + HaveId,
{
deserializer.deserialize_seq(SeqToMap(Default::default()))
}
pub struct SeqToMap<X>(PhantomData<X>);
impl<'de, X : Deserialize<'de> + HaveId> Visitor<'de> for SeqToMap<X> {
impl<'de, X: Deserialize<'de> + HaveId> Visitor<'de> for SeqToMap<X> {
type Value = HashMap<ID, X>;
fn expecting(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
@ -40,8 +40,8 @@ impl<'de, X : Deserialize<'de> + HaveId> Visitor<'de> for SeqToMap<X> {
}
fn visit_seq<A>(self, mut seq: A) -> Result<Self::Value, A::Error>
where
A: SeqAccess<'de>,
where
A: SeqAccess<'de>,
{
let mut map = HashMap::<ID, X>::new();

2
yopa/src/tests.rs
Unescape View File

@ -16,7 +16,7 @@ fn test1() {
}
"#;
let x : ObjectModel = serde_json::from_str(s).unwrap();
let x: ObjectModel = serde_json::from_str(s).unwrap();
println!("{}", serde_json::to_string_pretty(&x).unwrap());
}

8
yopa/src/update.rs
Unescape View File

@ -1,6 +1,6 @@
use serde::{Deserialize, Serialize};
use crate::{ID, TypedValue};
use crate::{TypedValue, ID};
/// Update or insert a value
#[derive(Debug, Clone, Serialize, Deserialize)]
@ -27,12 +27,12 @@ pub struct UpsertRelation {
}
/// Update an existing object
#[derive(Deserialize,Debug)]
#[derive(Deserialize, Debug)]
pub struct UpdateObj {
pub id: ID,
pub name: String,
pub values: Vec<UpsertValue>,
pub relations: Vec<UpsertRelation>
pub relations: Vec<UpsertRelation>,
}
#[cfg(test)]
@ -83,6 +83,6 @@ mod tests {
]
});
let obj : UpdateObj = serde_json::from_value(json).unwrap();
let _obj: UpdateObj = serde_json::from_value(json).unwrap();
}
}

Write Preview
Loading…
Cancel
Save