philipp/risp
1
1
Fork 0
Code Issues 19 Pull Requests Actions Packages Projects Releases Wiki Activity

rename

Browse Source
This commit is contained in:
philipp
2023-11-04 11:43:35 +01:00
parent c229cc01ca
commit 9206714c0c
3 changed files with 11 additions and 11 deletions
Download Patch File Download Diff File Expand all files Collapse all files

50
src/law/mod.rs
View File

@ -1,50 +0,0 @@
/// This module contains everything everything, to convert the given JSON file into Rust structs using serde.
mod parser;
use serde::Deserialize;
use time::{format_description, OffsetDateTime};
use crate::{law::parser::OgdSearchResult, Error};
/// Returns the current date in YYYY-MM-DD format. Needed for RIS API query to get current version of the law.
fn current_date() -> String {
let local_date = OffsetDateTime::now_utc();
let format = format_description::parse("[year]-[month]-[day]").unwrap(); //unwrap okay, supplied format is fine
local_date.format(&format).expect("Failed to format date")
}
/// Fetches the json content of the given law (`law_id`) from the RIS API.
///
/// # Errors
/// Fails if `ureq` can't create a connection, probably because there's no internet connection? (Or RIS is not online.)
fn fetch_page(law_id: usize) -> Result<String, Error> {
Ok(
ureq::post("https://data.bka.gv.at/ris/api/v2.6/Bundesrecht")
.send_form(&[
("Applikation", "BrKons"),
("Gesetzesnummer", &format!("{}", law_id)),
("DokumenteProSeite", "OneHundred"),
("Seitennummer", &format!("{}", 1)),
("Fassung.FassungVom", &current_date()),
])?
.into_string()?,
)
}
#[derive(Deserialize)]
#[serde(rename_all = "PascalCase")]
pub(crate) struct Wrapper {
ogd_search_result: OgdSearchResult,
}
pub(crate) fn parse(law_id: usize) -> Result<(), Error> {
let json = fetch_page(law_id)?;
let wrapper: Wrapper = serde_json::from_str(&json)?;
for par in wrapper.ogd_search_result.get_par() {
crate::par::parse(&par).unwrap();
}
Ok(())
}

242
src/law/parser.rs
View File

@ -1,242 +0,0 @@
use std::collections::HashMap;
use serde::Deserialize;
fn deserialize_string_to_usize<'de, D>(deserializer: D) -> Result<usize, D::Error>
where
D: serde::Deserializer<'de>,
{
let s = String::deserialize(deserializer)?;
s.parse().map_err(serde::de::Error::custom)
}
#[derive(Deserialize)]
#[serde(rename_all = "PascalCase")]
pub(crate) struct OgdSearchResult {
ogd_document_results: OgdDocumentResults,
}
impl OgdSearchResult {
fn has_next_page(&self) -> bool {
todo!();
}
pub(crate) fn get_par(&self) -> Vec<String> {
let mut ret = Vec::new();
for doc_ref in &self.ogd_document_results.ogd_document_reference {
for urls in &doc_ref
.data
.document_list
.content_reference
.urls
.content_url
{
if urls.data_type == "Xml" {
ret.push(urls.url.clone());
}
}
}
ret
}
}
#[derive(Deserialize)]
#[serde(rename_all = "PascalCase")]
pub(crate) struct OgdDocumentResults {
hits: Hits,
ogd_document_reference: Vec<OgdDocumentReference>,
}
#[derive(Deserialize)]
pub(crate) struct Hits {
#[serde(
rename = "@pageNumber",
deserialize_with = "deserialize_string_to_usize"
)]
page_number: usize,
#[serde(rename = "@pageSize", deserialize_with = "deserialize_string_to_usize")]
page_size: usize,
#[serde(rename = "#text", deserialize_with = "deserialize_string_to_usize")]
text: usize,
}
#[derive(Deserialize)]
#[serde(rename_all = "PascalCase")]
pub(crate) struct OgdDocumentReference {
data: Data,
}
#[derive(Deserialize)]
pub(crate) struct Data {
#[serde(rename = "Metadaten")]
metadata: Metadata,
#[serde(rename = "Dokumentliste")]
document_list: DocumentList,
}
#[derive(Deserialize)]
pub(crate) struct Metadata {
#[serde(rename = "Technisch")]
technical: TechnicalMetadata,
#[serde(rename = "Allgemein")]
general: GeneralMetadata,
#[serde(rename = "Bundesrecht")]
fed: FedMetadata,
}
#[derive(Deserialize)]
#[serde(rename_all = "PascalCase")]
pub(crate) struct TechnicalMetadata {
#[serde(rename = "ID")]
id: String,
#[serde(rename = "Applikation")]
application: String,
organ: String,
import_timestamp: ImportTimestamp,
}
#[derive(Deserialize)]
pub(crate) struct ImportTimestamp {
#[serde(rename = "@xsi:nil")]
xsi_nil: String, //TODO: switch to bool
#[serde(rename = "@xmlns:xsi")]
xmlns_xsi: String,
}
#[derive(Deserialize)]
pub(crate) struct GeneralMetadata {
#[serde(rename = "Geaendert")]
changed: String, //TODO: switch to YYYY-MM-DD string
#[serde(rename = "DokumentUrl")]
document_url: String,
}
#[derive(Deserialize)]
#[serde(rename_all = "PascalCase")]
pub(crate) struct FedMetadata {
#[serde(rename = "Kurztitel")]
short_title: String,
#[serde(rename = "Titel")]
title: Option<String>,
eli: String,
br_kons: BrKons,
}
#[derive(Deserialize)]
#[serde(rename_all = "PascalCase")]
pub(crate) struct BrKons {
kundmachungsorgan: String,
typ: String,
#[serde(rename = "Dokumenttyp")]
documenttype: String,
artikel_paragraph_anlage: String,
paragraphnummer: Option<String>,
stammnorm_publikationsorgan: String,
stammnorm_bgblnummer: String,
inkrafttretensdatum: String, //TODO: switch to date
#[serde(rename = "Indizes")]
indices: HashMap<String, String>, //e.g. "item": "22/04 Sonstiges Zivilprozess, Außerstreitiges Verfahren"
#[serde(rename = "Aenderung")]
change: String,
anmerkung: Option<String>,
schlagworte: Option<String>,
gesetzesnummer: String,
alte_dokumentnummer: Option<String>,
#[serde(rename = "GesamteRechtsvorschriftUrl")]
full_url: String,
}
#[derive(Deserialize)]
#[serde(rename_all = "PascalCase")]
pub(crate) struct DocumentList {
content_reference: ContentReference,
}
#[derive(Deserialize)]
#[serde(rename_all = "PascalCase")]
pub(crate) struct ContentReference {
content_type: String,
name: String,
urls: ContentUrl,
}
#[derive(Deserialize)]
#[serde(rename_all = "PascalCase")]
pub(crate) struct ContentUrl {
content_url: Vec<ContentUrlItem>,
}
#[derive(Deserialize)]
#[serde(rename_all = "PascalCase")]
pub(crate) struct ContentUrlItem {
data_type: String,
url: String,
}
#[cfg(test)]
mod tests {
use std::{fs::File, io::Read};
use super::*;
#[derive(Deserialize)]
#[serde(rename_all = "PascalCase")]
pub(crate) struct Wrapper {
ogd_search_result: OgdSearchResult,
}
#[test]
fn deserialize_teg_success() {
let mut file = File::open("data/teg.json").unwrap();
let mut json = String::new();
file.read_to_string(&mut json).unwrap();
let wrapper: serde_json::Result<Wrapper> = serde_json::from_str(&json);
if wrapper.is_err() {
let dbg = wrapper.as_ref().err().unwrap();
println!("{dbg:#?}");
}
assert!(wrapper.is_ok());
}
#[test]
fn deserialize_abgb_success() {
let mut file = File::open("data/abgb.json").unwrap();
let mut json = String::new();
file.read_to_string(&mut json).unwrap();
let wrapper: serde_json::Result<Wrapper> = serde_json::from_str(&json);
if wrapper.is_err() {
let dbg = wrapper.as_ref().err().unwrap();
println!("{dbg:#?}");
}
assert!(wrapper.is_ok());
}
#[test]
fn deserialize_urhg_success() {
let mut file = File::open("data/urhg.json").unwrap();
let mut json = String::new();
file.read_to_string(&mut json).unwrap();
let wrapper: serde_json::Result<Wrapper> = serde_json::from_str(&json);
if wrapper.is_err() {
let dbg = wrapper.as_ref().err().unwrap();
println!("{dbg:#?}");
}
assert!(wrapper.is_ok());
}
}