opsd 0.4.1

Rust client library for the Opsd API
Documentation
use serde::{Deserialize, Serialize};

use super::{domain::Employment, wire};
use crate::types::{EmployeeId, EmploymentId, ParseError, PayeSchemeId};

/// Request accepted when creating an employment.
#[derive(Clone, Debug, Serialize, Deserialize, PartialEq, Eq)]
#[serde(
    try_from = "wire::CreateEmploymentRequest",
    into = "wire::CreateEmploymentRequest"
)]
pub struct CreateEmploymentRequest {
    pub student_loan: crate::types::StudentLoan,
    pub postgraduate_loan: crate::types::PostgraduateLoan,
    pub normal_weekly_hours_band: crate::types::NormalWeeklyHoursBand,

    pub employee_id: EmployeeId,
    pub paye_scheme_id: PayeSchemeId,
    pub pay_schedule_id: crate::types::PayScheduleId,
    pub monthly_gross_pay_pence: crate::types::NonNegativePence,
    pub start_date: crate::types::EmploymentDate,
    pub ni_category: crate::types::NiCategory,
    pub starter_information: crate::types::StarterInformation,
}

/// Response returned after creating an employment.
#[derive(Clone, Debug, Serialize, Deserialize, PartialEq, Eq)]
#[serde(try_from = "wire::Employment", into = "wire::Employment")]
pub struct CreateEmploymentResponse {
    pub employment: Employment,
}

/// Response returned when listing a business's employments.
#[derive(Clone, Debug, Serialize, Deserialize, PartialEq, Eq)]
#[serde(try_from = "Vec<wire::Employment>", into = "Vec<wire::Employment>")]
pub struct ListEmploymentsResponse {
    pub employments: Vec<Employment>,
}

impl From<CreateEmploymentRequest> for wire::CreateEmploymentRequest {
    fn from(value: CreateEmploymentRequest) -> Self {
        Self {
            student_loan: value.student_loan,
            postgraduate_loan: value.postgraduate_loan,
            employee_id: value.employee_id.to_string(),
            paye_scheme_id: value.paye_scheme_id.to_string(),
            pay_schedule_id: value.pay_schedule_id.to_string(),
            normal_weekly_hours_band: value.normal_weekly_hours_band,
            monthly_gross_pay_pence: value.monthly_gross_pay_pence,
            start_date: value.start_date,
            ni_category: value.ni_category,
            starter_information: value.starter_information,
        }
    }
}

impl TryFrom<wire::CreateEmploymentRequest> for CreateEmploymentRequest {
    type Error = ParseError;

    fn try_from(value: wire::CreateEmploymentRequest) -> Result<Self, Self::Error> {
        Ok(Self {
            student_loan: value.student_loan,
            postgraduate_loan: value.postgraduate_loan,
            employee_id: EmployeeId::parse(&value.employee_id)?,
            paye_scheme_id: PayeSchemeId::parse(&value.paye_scheme_id)?,
            pay_schedule_id: crate::types::PayScheduleId::parse(&value.pay_schedule_id)?,
            normal_weekly_hours_band: value.normal_weekly_hours_band,
            monthly_gross_pay_pence: value.monthly_gross_pay_pence,
            start_date: value.start_date,
            ni_category: value.ni_category,
            starter_information: value.starter_information,
        })
    }
}

fn employment_from_wire(value: wire::Employment) -> Result<Employment, ParseError> {
    Ok(Employment {
        id: EmploymentId::parse(&value.id)?,
        student_loan: value.student_loan,
        postgraduate_loan: value.postgraduate_loan,
        employee_id: EmployeeId::parse(&value.employee_id)?,
        paye_scheme_id: PayeSchemeId::parse(&value.paye_scheme_id)?,
        pay_schedule_id: crate::types::PayScheduleId::parse(&value.pay_schedule_id)?,
        payroll_settings: value.payroll_settings,
        created_at: value.created_at,
    })
}

fn employment_into_wire(value: Employment) -> wire::Employment {
    wire::Employment {
        id: value.id.to_string(),
        student_loan: value.student_loan,
        postgraduate_loan: value.postgraduate_loan,
        employee_id: value.employee_id.to_string(),
        paye_scheme_id: value.paye_scheme_id.to_string(),
        pay_schedule_id: value.pay_schedule_id.to_string(),
        payroll_settings: value.payroll_settings,
        created_at: value.created_at,
    }
}

impl TryFrom<wire::Employment> for CreateEmploymentResponse {
    type Error = ParseError;

    fn try_from(value: wire::Employment) -> Result<Self, Self::Error> {
        Ok(Self {
            employment: employment_from_wire(value)?,
        })
    }
}

impl From<CreateEmploymentResponse> for wire::Employment {
    fn from(value: CreateEmploymentResponse) -> Self {
        employment_into_wire(value.employment)
    }
}

impl TryFrom<Vec<wire::Employment>> for ListEmploymentsResponse {
    type Error = ParseError;

    fn try_from(values: Vec<wire::Employment>) -> Result<Self, Self::Error> {
        Ok(Self {
            employments: values
                .into_iter()
                .map(employment_from_wire)
                .collect::<Result<_, _>>()?,
        })
    }
}

impl From<ListEmploymentsResponse> for Vec<wire::Employment> {
    fn from(value: ListEmploymentsResponse) -> Self {
        value
            .employments
            .into_iter()
            .map(employment_into_wire)
            .collect()
    }
}

/// Response for reading an employment.
pub type GetEmploymentResponse = CreateEmploymentResponse;
/// Response after updating an employment.
pub type UpdateEmploymentResponse = CreateEmploymentResponse;