Challenge create

Author: Sergey Kudryashov

src/credential.rs

@@ -1,44 +1,61 @@
 
+#![allow(unused_variables)]
+#![allow(dead_code)]
+
+type CredentialSubject = serde_json::Value;
+type CredentialTypes = [VerifiableCredential];
+
 
 // #[derive(Deserialize, Debug)]
 pub struct VerifiableCredential {
 	context: String,
 	id: String,
-    credType: String,
+    cred_type: String,
 	issuer: String,
-	issuanceDate: String,
+	issuance_date: String,
 	subject: CredentialSubject,
 	proof: *mut CredentialProof,
 }
 
 impl <'a> VerifiableCredential {
-    pub fn init(credType: &'a str, credSubject: serde_json::Value) -> Self  {
+    pub fn init(cred_type: &'a str, cred_subject: serde_json::Value) -> Self  {
         Self {
-            context: String::default(), // array defined by us 
-            id: String::default(), // provided  by client 
-            credType: String::from(credType),
-            issuer: String::default(), // provided  by client 
-            issuanceDate: String::default(),
-            subject: credSubject, //
-            proof: &mut CredentialProof{ // we don't have it 
-                proofType:String::default(),
+            /// context is a slice, it is  defined by us based on parsed cred type and cred subject
+            context: String::default(), 
+            /// provided  by client
+            id: String::default(), 
+            cred_type: String::from(cred_type),
+            /// provided  by client 
+            issuer: String::default(), 
+            issuance_date: String::default(),
+            subject: cred_subject,
+            /// created empty object on VerifiableCredential init step, will be filled on "create_data_integrity_proof" step
+            proof: &mut CredentialProof { 
+                proof_type:String::default(),
                 created:String::default(),
-                verificationMethod:String::default(),
-                proofPurpose:String::default(),
-                proofValue:String::default(),
+                verification_method:String::default(),
+                proof_purpose:String::default(),
+                proof_value:String::default(),
             },
         }
     }
+
+    pub fn serialize(self) -> serde_json::Value {
+        return self.subject
+    }
 }
 
 
 pub struct CredentialProof {
-	proofType: String,
+	proof_type: String,
 	created: String,
-	verificationMethod: String,
-	proofPurpose: String,
-	proofValue: String,
+	verification_method: String,
+	proof_purpose: String,
+	proof_value: String,
 }
 
-type CredentialSubject = serde_json::Value;
-
+pub struct VerifiablePresentation {
+    nonce: String,
+    endpoint: String, 
+    credential_types: CredentialTypes,
+}

src/lib.rs

@@ -3,7 +3,6 @@ use serde_json;
 use credential::*;
 use serde::Deserialize;
 use serde_json::Map;
-// pub use crate::map::Map;
 
 /// Verification of Data Integrity Proofs requires the resolution of the `verificationMethod` specified in the proof.
 /// The `verificationMethod` refers to a cryptographic key stored in some external source.
@@ -23,8 +22,7 @@ pub fn create_credential(
     _cred_subject: serde_json::Value,
 ) -> Result<serde_json::Value, Box<dyn std::error::Error>> {
     let vc = VerifiableCredential::init(_cred_type, _cred_subject);
-    Ok(_cred_subject)
-    // let vcVec = serde_json::from_str(_cred_type.unwrap();
+    Ok(vc.serialize())
 }
 
 /// Given the set of credentials, create a unsigned JSON-LD Presentation of those credentials.