use rust_decimal::Decimal;
use crate::{Error, Result};
pub use super::super::id::LegacyId;
pub type UnitTypeDescription = String;
pub type UnitUseDescription = String;
#[derive(Clone, Eq, Hash, PartialEq)]
#[non_exhaustive]
pub enum HouseNumberKind {
Descriptive,
Evidentiary,
Other(String),
}
impl HouseNumberKind {
pub fn from_raw(raw: String) -> Self {
match raw.as_str() {
"1" => Self::Descriptive,
"2" => Self::Evidentiary,
_ => Self::Other(raw),
}
}
pub fn as_str(&self) -> &str {
match self {
Self::Descriptive => "1",
Self::Evidentiary => "2",
Self::Other(raw) => raw,
}
}
}
#[derive(Clone, Default, Eq, PartialEq)]
pub struct Address {
pub groups: Vec<AddressGroup>,
}
#[derive(Clone, Default, Eq, PartialEq)]
pub struct AddressGroup {
pub address_point_id: Option<LegacyId>,
pub street_name: Option<String>,
pub house_number_kind: Option<HouseNumberKind>,
pub house_number: Option<String>,
pub orientation_number: Option<String>,
pub municipality_part: Option<String>,
pub municipality: Option<String>,
pub city_district: Option<String>,
pub city_borough: Option<String>,
pub postal_code: Option<String>,
pub delivery_post_office: Option<String>,
pub country_name: Option<String>,
}
#[derive(Clone, Default, Eq, PartialEq)]
pub struct DeedName {
pub details: Option<DeedNameDetails>,
}
#[derive(Clone, Eq, PartialEq)]
pub struct DeedNameDetails {
pub deed_type: String,
pub additional_data: String,
pub preparation_serial_number: String,
pub description: String,
pub issuance_text: String,
pub legal_force_text: String,
pub submission_text: String,
pub enforceability_text: String,
pub submission_z_text: String,
pub effectiveness_text: String,
pub handling_workplace_name: Option<String>,
}
#[derive(Clone, Default, Eq, PartialEq)]
pub struct ParcelWrapper {
pub parcel: Option<Parcel>,
}
#[derive(Clone, Default, Eq, PartialEq)]
pub struct Parcel {
pub id: Option<LegacyId>,
pub kind_abbreviation: Option<String>,
pub numbering_kind: Option<String>,
pub number: Option<String>,
pub subdivision: Option<String>,
pub part: Option<i8>,
pub ownership_sheet_id: Option<LegacyId>,
pub ownership_sheet_number: Option<String>,
pub cadastral_area_name: Option<String>,
pub original_cadastral_area_name: Option<String>,
}
#[derive(Clone, Default, Eq, PartialEq)]
pub struct BuildingWrapper {
pub building: Option<Building>,
}
#[derive(Clone, Default, Eq, PartialEq)]
pub struct Building {
pub id: Option<LegacyId>,
pub municipality_part: Option<String>,
pub building_type_abbreviation: Option<String>,
pub house_numbers: Option<String>,
pub use_abbreviation: Option<String>,
pub ownership_sheet_id: Option<LegacyId>,
pub without_ownership_sheet: Option<String>,
pub ownership_sheet_number: Option<String>,
pub cadastral_area_name: Option<String>,
pub temporary: Option<String>,
pub identifying_parcels: Option<Vec<Parcel>>,
}
#[derive(Clone, Default, Eq, PartialEq)]
pub struct UnitWrapper {
pub unit: Option<Unit>,
}
#[derive(Clone, Eq, PartialEq)]
pub struct Unit {
pub id: LegacyId,
pub municipality_part: Option<String>,
pub building_identification: Option<String>,
pub unit_identification: Option<String>,
pub ownership_sheet_id: Option<LegacyId>,
pub ownership_sheet_number: Option<String>,
pub cadastral_area_name: Option<String>,
}
#[derive(Clone, Default, Eq, PartialEq)]
pub struct BuildingRightWrapper {
pub building_right: Option<BuildingRight>,
}
#[derive(Clone, Default, Eq, PartialEq)]
pub struct BuildingRight {
pub id: Option<LegacyId>,
pub ownership_sheet_id: Option<LegacyId>,
pub parcels: Vec<Parcel>,
pub ownership_sheet_number: Option<String>,
pub cadastral_area_name: Option<String>,
}
#[derive(Clone, Default, Eq, PartialEq)]
pub struct Proceeding {
pub identification: Option<ProceedingIdentification>,
}
#[derive(Clone, Eq, PartialEq)]
pub struct ProceedingIdentification {
pub type_code: String,
pub serial_number: u32,
pub year: u16,
pub workplace_code: u16,
}
#[derive(Clone, Default, Eq, PartialEq)]
pub struct Characteristic {
pub details: Option<CharacteristicDetails>,
}
#[derive(Clone, Copy, Eq, Hash, Ord, PartialEq, PartialOrd)]
pub struct CharacteristicCode(u8);
impl CharacteristicCode {
pub fn new(value: u8) -> Result<Self> {
if (1..=99).contains(&value) {
Ok(Self(value))
} else {
Err(Error::invalid_input(
"characteristic_code",
"expected a code in 1..=99",
))
}
}
pub fn get(self) -> u8 {
self.0
}
}
impl TryFrom<u8> for CharacteristicCode {
type Error = Error;
fn try_from(value: u8) -> Result<Self> {
Self::new(value)
}
}
impl From<CharacteristicCode> for u8 {
fn from(value: CharacteristicCode) -> Self {
value.get()
}
}
#[derive(Clone, Eq, PartialEq)]
pub struct CharacteristicDetails {
pub code: CharacteristicCode,
pub abbreviation: String,
pub alv_abbreviation: String,
}
#[derive(Clone, Default, Eq, PartialEq)]
pub struct CharacteristicWrapper {
pub characteristic: Option<Characteristic>,
}
#[derive(Clone, Eq, PartialEq)]
#[non_exhaustive]
pub enum AuthorizedSubjectField {
Id(LegacyId),
PersonalNumber6(String),
PersonalNumber7(String),
CompanyId(String),
CompanyIdSuffix(String),
Characteristic(Characteristic),
Partner1Id(LegacyId),
Partner2Id(LegacyId),
Surname(String),
GivenName(String),
TitleBefore(String),
TitleAfter(String),
Partner1Surname(String),
Partner1GivenName(String),
Partner1TitleBefore(String),
Partner1TitleAfter(String),
Partner2Surname(String),
Partner2GivenName(String),
Partner2TitleBefore(String),
Partner2TitleAfter(String),
Name(String),
Address(Address),
}
#[derive(Clone, Default, Eq, PartialEq)]
pub struct AuthorizedSubjectIdentification {
pub entries: Vec<AuthorizedSubjectField>,
}
#[derive(Clone, Eq, PartialEq)]
#[non_exhaustive]
pub enum OwnershipTarget {
Subject(AuthorizedSubjectIdentification),
Parcel(Parcel),
Building(Building),
Unit(Unit),
BuildingRight(BuildingRight),
}
#[derive(Clone, Default, Eq, PartialEq)]
pub struct OwnershipIdentification {
pub targets: Vec<OwnershipTarget>,
}
#[derive(Clone, Eq, PartialEq)]
#[non_exhaustive]
pub enum LegalEntityIdentificationEntry {
Field(AuthorizedSubjectField),
AuthorizedSubject(AuthorizedSubjectIdentification),
}
#[derive(Clone, Default, Eq, PartialEq)]
pub struct LegalEntityIdentification {
pub entries: Vec<LegalEntityIdentificationEntry>,
}
#[derive(Clone, Eq, PartialEq)]
#[non_exhaustive]
pub enum AuthorizedSubjectPoEntry {
AuthorizedLegalEntity(LegalEntityIdentification),
Field(AuthorizedSubjectField),
}
#[derive(Clone, Default, Eq, PartialEq)]
pub struct AuthorizedSubjectPoIdentification {
pub entries: Vec<AuthorizedSubjectPoEntry>,
}
#[derive(Clone, Default, Eq, PartialEq)]
pub struct PersonNameForm {
pub surname: Option<String>,
pub given_name: Option<String>,
pub title_before: Option<String>,
pub title_after: Option<String>,
}
#[derive(Clone, Default, Eq, PartialEq)]
pub struct SubjectNameForm {
pub id: Option<LegacyId>,
pub partner1_id: Option<LegacyId>,
pub partner2_id: Option<LegacyId>,
pub name: Option<String>,
pub person: PersonNameForm,
pub partner1: PersonNameForm,
pub partner2: PersonNameForm,
}
#[derive(Clone, Eq, PartialEq)]
#[non_exhaustive]
pub enum PropertyTarget {
Parcel(Parcel),
Building(Building),
Unit(Unit),
BuildingRight(BuildingRight),
}
#[derive(Clone, Default, Eq, PartialEq)]
pub struct PropertyIdentification {
pub targets: Vec<PropertyTarget>,
}
#[derive(Clone, Copy, Default, Eq, PartialEq)]
pub struct ReportedShare {
pub numerator: Option<Decimal>,
pub denominator: Option<Decimal>,
}
#[derive(Clone, Default, Eq, PartialEq)]
pub struct SubjectPropertyIdentification {
pub legal_relation_id: Option<LegacyId>,
pub ownership_sheet_id: Option<LegacyId>,
pub ownership_sheet_number: Option<String>,
pub subject: Option<AuthorizedSubjectPoIdentification>,
pub parcel: Option<Parcel>,
pub building: Option<Building>,
pub unit: Option<Unit>,
pub building_right: Option<BuildingRight>,
}
#[derive(Clone, Eq, Hash, PartialEq)]
#[non_exhaustive]
pub enum DeedSection {
B1,
C,
D,
Other(String),
}
impl DeedSection {
pub fn from_raw(raw: String) -> Self {
match raw.as_str() {
"B1" => Self::B1,
"C" => Self::C,
"D" => Self::D,
_ => Self::Other(raw),
}
}
pub fn as_str(&self) -> &str {
match self {
Self::B1 => "B1",
Self::C => "C",
Self::D => "D",
Self::Other(raw) => raw,
}
}
}
#[derive(Clone, Eq, Hash, PartialEq)]
#[non_exhaustive]
pub enum YesNo {
Yes,
No,
Other(String),
}
impl YesNo {
pub fn from_raw(raw: String) -> Self {
match raw.as_str() {
"a" => Self::Yes,
"n" => Self::No,
_ => Self::Other(raw),
}
}
pub fn as_str(&self) -> &str {
match self {
Self::Yes => "a",
Self::No => "n",
Self::Other(raw) => raw,
}
}
}
#[derive(Clone, Copy, Eq, PartialEq)]
pub struct Number102(Decimal);
impl Number102 {
pub fn new(value: Decimal) -> Result<Self> {
let value = value.normalize();
if value.scale() > 2 || decimal_digits(value) > 10 {
return Err(Error::invalid_input(
"number102",
"expected an exact decimal with at most 10 total and 2 fractional digits",
));
}
Ok(Self(value))
}
pub fn as_decimal(&self) -> &Decimal {
&self.0
}
pub fn into_decimal(self) -> Decimal {
self.0
}
}
impl From<Number102> for Decimal {
fn from(value: Number102) -> Self {
value.into_decimal()
}
}
fn decimal_digits(value: Decimal) -> usize {
value.mantissa().unsigned_abs().to_string().len()
}