mod.rs

use failure::Fail;
use yaserde_derive::YaSerialize;
use yaserde;
use crate::entities::bpmn::datatypes::{process::Process, bpmndi_bpmn_diagram::DiBPMNDiagram};

pub mod config;
pub mod datatypes;

#[derive(Fail, Debug)]
pub enum BPMNError {
    #[fail(display = "The Business Process Model cannot be serialized. ({})", _0)]
    SerializationFailed(String),
}

#[derive(Debug, YaSerialize)]
#[yaserde(rename = "bpmn:definitions")]
pub struct Definitions {
    #[yaserde(attribute)]
    pub xmlns: Option<String>,
    #[yaserde(attribute, rename = "xmlns:xsi")]
    pub xmlns_xsi: Option<String>,
    #[yaserde(attribute, rename = "xmlns:camunda")]
    pub xmlns_camunda: Option<String>,
    #[yaserde(attribute, rename = "xmlns:xsd")]
    pub xmlns_xsd: Option<String>,
    #[yaserde(attribute, rename = "xmlns:activiti")]
    pub xmlns_activiti: Option<String>,
    #[yaserde(attribute, rename = "xmlns:bpmndi")]
    pub xmlns_bpmndi: Option<String>,
    #[yaserde(attribute, rename = "xmlns:omgdc")]
    pub xmlns_omgdc: Option<String>,
    #[yaserde(attribute, rename = "xmlns:omgdi")]
    pub xmlns_omgdi: Option<String>,
    #[yaserde(attribute, rename = "xmlns:bpmn2")]
    pub xmlns_bpmn2: Option<String>,
    #[yaserde(attribute, rename = "xmlns:dc")]
    pub xmlns_dc: Option<String>,
    #[yaserde(attribute, rename = "xmlns:di")]
    pub xmlns_di: Option<String>,
    #[yaserde(attribute, rename = "xmlns:g")]
    pub xmlns_g: Option<String>,
    #[yaserde(attribute, rename = "xmlns:java")]
    pub xmlns_java: Option<String>,
    #[yaserde(attribute, rename = "xmlns:tns")]
    pub xmlns_tns: Option<String>,
    #[yaserde(attribute, rename = "typeLanguage")]
    pub type_language: Option<String>,
    #[yaserde(attribute, rename = "expressionLanguage")]
    pub expression_language: Option<String>,
    #[yaserde(attribute, rename = "targetNamespace")]
    pub target_namespace: Option<String>,
    #[yaserde(attribute, rename = "xsi:schemaLocation")]
    pub xsi_schema_location: Option<String>,
    #[yaserde(attribute)]
    pub id: Option<String>,
    #[yaserde(attribute)]
    pub exporter: Option<String>,
    #[yaserde(attribute, rename = "exporterVersion")]
    pub exporter_version: Option<String>,
    /*
     * Assumption for PoC: Each BPMN contains exactly one process.
     */
    #[yaserde(child, rename = "bpmn2:process")]
    pub process: Process,
    #[yaserde(child, rename = "bpmndi:BPMNDiagram")]
    pub bpmndi_bpmn_diagram: DiBPMNDiagram
}

impl Definitions {
    pub fn init(process_id: String, process_name: Option<String>) -> Definitions {
        Definitions {
            xmlns: Some(config::XMLNS.to_string()),
            xmlns_xsi: Some(config::XMLNS_XSI.to_string()),
            xmlns_camunda: Some(config::XMLNS_CAMUNDA.to_string()), 
            xmlns_xsd: Some(config::XMLNS_XSD.to_string()),
            xmlns_activiti: Some(config::XMLNS_ACTIVITI.to_string()),
            xmlns_bpmndi: Some(config::XMLNS_BPMNDI.to_string()),
            xmlns_omgdc: Some(config::XMLNS_OMGDC.to_string()),
            xmlns_omgdi: Some(config::XMLNS_OMGDI.to_string()),
            xmlns_bpmn2: Some(config::XMLNS_BPMN2.to_string()),
            xmlns_dc: Some(config::XMLNS_DC.to_string()),
            xmlns_di: Some(config::XMLNS_DI.to_string()),
            xmlns_g: Some(config::XMLNS_G.to_string()),
            xmlns_java: Some(config::XMLNS_JAVA.to_string()),
            xmlns_tns: Some(config::XMLNS_TNS.to_string()),
            type_language: Some(config::TYPE_LANGUAGE.to_string()),
            expression_language: Some(config::EXPRESSION_LANGUAGE.to_string()),
            target_namespace: Some(config::TARGET_NAMESPACE.to_string()),
            xsi_schema_location: Some(config::XSI_SCHEMA_LOCATION.to_string()),
            id: Some("Definition".to_string()),
            exporter: Some(config::EXPORTER.to_string()),
            exporter_version: Some(config::EXPORTER_VERSION.to_string()),
            process: Process::init(process_id.clone(), process_name),
            bpmndi_bpmn_diagram: DiBPMNDiagram::init(process_id.clone())
        }
    }
}

pub fn serialize(definitions: Definitions) -> Result<String, BPMNError>{
    let bpmn_xml = yaserde::ser::to_string(&definitions)
        .map_err(|error| BPMNError::SerializationFailed(error))?;
    Ok(bpmn_xml)
}