1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57

extern crate serde_json;
use context::Context;
use holochain_core_types::{entry_type::EntryType, error::HolochainError};
use nucleus::{
    ribosome::{
        self,
        callback::{get_dna, get_wasm, CallbackResult},
    },
    ZomeFnCall,
};
use std::sync::Arc;

pub fn get_validation_package_definition(
    entry_type: EntryType,
    context: Arc<Context>,
) -> Result<CallbackResult, HolochainError> {
    match entry_type {
        EntryType::App(app_entry_type) => {
            let dna = get_dna(&context).expect("Callback called without DNA set!");
            let zome_name = dna.get_zome_name_for_entry_type(&app_entry_type);
            if zome_name.is_none() {
                return Ok(CallbackResult::NotImplemented);
            }

            let zome_name = zome_name.unwrap();
            let wasm = get_wasm(&context, &zome_name)
                .ok_or(HolochainError::ErrorGeneric(String::from("no wasm found")))?;

            let result = ribosome::run_dna(
                &dna.name.clone(),
                context,
                wasm.code.clone(),
                &ZomeFnCall::new(
                    &zome_name,
                    "no capability, since this is an entry validation call",
                    "__hdk_get_validation_package_for_entry_type",
                    &app_entry_type,
                ),
                Some(app_entry_type.into_bytes()),
            )?;

            if result.is_empty() {
                Err(HolochainError::SerializationError(String::from(
                    "__hdk_get_validation_package_for_entry_type returned empty result",
                )))
            } else {
                match serde_json::from_str(&result) {
                    Ok(package) => Ok(CallbackResult::ValidationPackageDefinition(package)),
                    Err(_) => Err(HolochainError::SerializationError(String::from(
                        "validation_package result could not be deserialized as ValidationPackage",
                    ))),
                }
            }
        }
        _ => Err(HolochainError::NotImplemented),
    }
}