API was finished

did_router/src/database.rs

@@ -5,9 +5,10 @@ use dotenvy::dotenv;
 use std::env;
 use serde::{Serialize};
 use diesel_derive_enum::DbEnum;
+use std::str::FromStr;
+use strum_macros::EnumString;
 
-
-#[derive(Debug, PartialEq, DbEnum, Serialize)]
+#[derive(Debug, PartialEq, DbEnum, Serialize, EnumString)]
 #[db_enum(existing_type_path = "crate::schema::sql_types::DidTargetType")]
 pub enum DidTargetType {
     #[db_enum(rename ="URL")]
@@ -24,12 +25,12 @@ pub enum DidTargetType {
     CustomMessage
 }
 
-#[derive(Queryable, Selectable, Serialize)]
+#[derive(Queryable, Selectable, Serialize, AsChangeset)]
 #[diesel(table_name = crate::schema::dids)]
 #[diesel(check_for_backend(diesel::pg::Pg))]
 pub struct Did {
     pub id: i32,
-    pub did: String,
+    pub did_number: String,
     pub target_type: DidTargetType,
     pub target: Option<String>,
     pub active: bool
@@ -38,7 +39,7 @@ pub struct Did {
 #[derive(Insertable)]
 #[diesel(table_name = crate::schema::dids)]
 pub struct NewDid<'a> {
-    pub did: &'a str,
+    pub did_number: &'a str,
     pub target_type: DidTargetType,
     pub target: Option<&'a str>,
     pub active: bool
@@ -52,15 +53,51 @@ pub fn connect() -> PgConnection {
         .unwrap_or_else(|_| panic!("Error connecting to database"))
 }
 
-pub fn add_did() -> Result<Did, Error> {
+pub fn get_did(a_id :i32) -> Result<Did, Error> {
+    use crate::schema::dids::dsl::*;
+
+    let mut conn = connect();
+    let result = dids.find(a_id).first(&mut conn)?;
+
+    Ok(result)
+}
+
+pub fn delete_did(i: i32) -> Result<(), Error> {
+    use crate::schema::dids;
+    use crate::schema::dids::columns::id;
+
+    let mut conn = connect();
+    diesel::delete(dids::table)
+        .filter(id.eq(i))
+        .execute(&mut conn)?;
+
+    Ok(())
+}
+
+pub fn update_did(d: Did)-> Result<(), Error> {
+    use crate::schema::dids;
+    use crate::schema::dids::dsl::*;
+
+    let mut conn = connect();
+
+    diesel::update(dids::table)
+        .filter(id.eq(d.id))
+        .set(d)
+        .execute(&mut conn)?;
+
+    Ok(())
+}
+
+pub fn add_did(did_number: &str, target_type: &str, target: &str, active: bool)
+               -> Result<Did, Error> {
     use crate::schema::dids;
 
     let mut conn = connect();
     let new_did = NewDid {
-        did: "123456",
-        target_type: DidTargetType::Url,
-        target: Some("123456"),
-        active: true
+        did_number: did_number,
+        target_type: DidTargetType::from_str(target_type).unwrap(),
+        target: Some(target),
+        active: active
     };
 
     let did = diesel::insert_into(dids::table)

did_router/src/main.rs

@@ -1,19 +1,35 @@
 pub mod database;
 pub mod schema;
 
+use std::ops::Deref;
+use std::str::FromStr;
 use xml_builder::{XMLBuilder, XMLElement, XMLVersion};
-use actix_web::{get, post, web, App,
+use actix_web::{web, App,
                 HttpResponse,
                 HttpServer,
                 http::header::ContentType,
                 Responder,
 };
+use serde::Deserialize;
+use database as db;
+use database::DidTargetType;
 
-use database::{ add_did,
-                list_did
-};
+#[derive(Debug, Deserialize)]
+struct RouteData {
+    #[serde(rename = "Caller-Destination-Number")]
+    dest_did: String
+}
 
-async fn route_did() -> impl Responder {
+#[derive(Debug, Deserialize)]
+struct JsonDid {
+    did_number: String,
+    target_type: String,
+    target: String,
+    active: bool
+}
+
+async fn route_did(data: web::Form<RouteData>) -> impl Responder {
+    let _dest_did = data.dest_did.clone();
     let mut xml = XMLBuilder::new()
         .version(XMLVersion::XML1_1)
         .encoding("UTF-8".into())
@@ -43,29 +59,60 @@ async fn route_did() -> impl Responder {
         .body(writer)
 }
 
-async fn did_post() -> impl Responder {
-    add_did().unwrap();
+async fn did_post(d: web::Json<JsonDid>) -> impl Responder {
+    let did = d.deref();
+
+    db::add_did(&did.did_number, &did.target_type, &did.target, did.active).unwrap();
     HttpResponse::Ok().body("DID added.")
 }
 
 async fn did_index() -> impl Responder {
-    let dids = list_did().unwrap();
+    let dids = db::list_did().unwrap();
     HttpResponse::Ok().json(dids)
 }
 
+async fn did_get(path: web::Path<i32>) ->  impl Responder {
+    let id = path.into_inner();
+    let did = db::get_did(id).unwrap();
+
+    HttpResponse::Ok().json(did)
+}
+
+async fn did_patch(d: web::Json<JsonDid>, path: web::Path<i32>) -> impl Responder {
+    let id = path.into_inner();
+    let d = d.deref();
+    let did = db::Did {
+        id: id,
+        did_number: d.did_number.clone(),
+        target_type: DidTargetType::from_str(&d.target_type).unwrap(),
+        target: Some(d.target.clone()),
+        active: d.active
+    };
+
+    db::update_did(did).unwrap();
+
+    HttpResponse::Ok().body("DID updated")
+}
+
+async fn did_delete(path: web::Path<i32>) -> impl Responder {
+    let id = path.into_inner();
+
+    db::delete_did(id).unwrap();
+
+    HttpResponse::Ok().body("DID deleted.")
+}
+
 fn api_config(cfg: &mut web::ServiceConfig) {
     cfg.service(
         web::resource("/fs")
             .route(web::get().to(did_index))
             .route(web::post().to(did_post))
-            .route(web::patch().to(|| async { HttpResponse::Ok().body("did patch") }))
-            .route(web::delete().to(|| async { HttpResponse::Ok().body("did delete") }))
     );
     cfg.service(
         web::resource("/fs/{id}")
-            .route(web::get().to(|| async { HttpResponse::Ok().body("did get")}))
-            .route(web::patch().to(|| async { HttpResponse::Ok().body("did patch")}))
-            .route(web::delete().to(|| async { HttpResponse::Ok().body("did delete")}))
+            .route(web::get().to(did_get))
+            .route(web::patch().to(did_patch))
+            .route(web::delete().to(did_delete))
     );
     cfg.service(
         web::resource("/route_did")

did_router/src/schema.rs

@@ -13,7 +13,7 @@ diesel::table! {
     dids (id) {
         id -> Int4,
         #[max_length = 64]
-        did -> Varchar,
+        did_number -> Varchar,
         target_type -> DidTargetType,
         #[max_length = 512]
         target -> Nullable<Varchar>,