Database and api route ready

did_router/src/database.rs

@@ -0,0 +1,82 @@
+use diesel::prelude::*;
+use diesel::pg::PgConnection;
+use diesel::result::Error;
+use dotenvy::dotenv;
+use std::env;
+use serde::{Serialize};
+use diesel_derive_enum::DbEnum;
+
+
+#[derive(Debug, PartialEq, DbEnum, Serialize)]
+#[db_enum(existing_type_path = "crate::schema::sql_types::DidTargetType")]
+pub enum DidTargetType {
+    #[db_enum(rename ="URL")]
+    Url,
+    #[db_enum(rename ="MOH")]
+    Moh,
+    #[db_enum(rename ="EXTERNAL_NUMBER")]
+    ExternalNumber,
+    #[db_enum(rename ="NO_SERVICE")]
+    NoService,
+    #[db_enum(rename ="NIGHT_MODE")]
+    NightMode,
+    #[db_enum(rename ="CUSTOME_MESSAGE")]
+    CustomMessage
+}
+
+#[derive(Queryable, Selectable, Serialize)]
+#[diesel(table_name = crate::schema::dids)]
+#[diesel(check_for_backend(diesel::pg::Pg))]
+pub struct Did {
+    pub id: i32,
+    pub did: String,
+    pub target_type: DidTargetType,
+    pub target: Option<String>,
+    pub active: bool
+}
+
+#[derive(Insertable)]
+#[diesel(table_name = crate::schema::dids)]
+pub struct NewDid<'a> {
+    pub did: &'a str,
+    pub target_type: DidTargetType,
+    pub target: Option<&'a str>,
+    pub active: bool
+}
+
+pub fn connect() -> PgConnection {
+    dotenv().ok();
+
+    let database_url = env::var("DATABASE_URL").expect("DATABASE_URL must be set");
+    PgConnection::establish(&database_url)
+        .unwrap_or_else(|_| panic!("Error connecting to database"))
+}
+
+pub fn add_did() -> 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
+    };
+
+    let did = diesel::insert_into(dids::table)
+        .values(&new_did)
+        .returning(Did::as_returning())
+        .get_result(&mut conn)?;
+
+    Ok(did)
+}
+
+pub fn list_did() ->Result<Vec<Did>, Error> {
+    use crate::schema::dids::dsl::*;
+    let mut conn = connect();
+
+    let res = dids
+        .load(&mut conn)?;
+
+    Ok(res)
+}

did_router/src/main.rs

@@ -1,28 +1,86 @@
-use actix_web::{get, post, web, App, HttpResponse, HttpServer, Responder};
+pub mod database;
+pub mod schema;
 
-#[get("/")]
-async fn hello() -> impl Responder {
-    HttpResponse::Ok().body("Hello world!")
+use xml_builder::{XMLBuilder, XMLElement, XMLVersion};
+use actix_web::{get, post, web, App,
+                HttpResponse,
+                HttpServer,
+                http::header::ContentType,
+                Responder,
+};
+
+use database::{ add_did,
+                list_did
+};
+
+async fn route_did() -> impl Responder {
+    let mut xml = XMLBuilder::new()
+        .version(XMLVersion::XML1_1)
+        .encoding("UTF-8".into())
+        .build();
+
+    let mut doc = XMLElement::new("document");
+    doc.add_attribute("type", "xml/freeswitch-httapi");
+
+    let params = XMLElement::new("params");
+    let mut work = XMLElement::new("work");
+
+    let mut playback = XMLElement::new("playback");
+    playback.add_attribute("name", "exten");
+    playback.add_attribute("file", "ivr/ivr-welcome_to_freeswitch.wav");
+    work.add_child(playback).unwrap();
+
+    doc.add_child(params).unwrap();
+    doc.add_child(work).unwrap();
+
+    xml.set_root_element(doc);
+
+    let mut writer: Vec<u8> = Vec::new();
+    xml.generate(&mut writer).unwrap();
+
+    HttpResponse::Ok()
+        .content_type(ContentType::xml())
+        .body(writer)
 }
 
-#[post("/echo")]
-async fn echo(req_body: String) -> impl Responder {
-    HttpResponse::Ok().body(req_body)
+async fn did_post() -> impl Responder {
+    add_did().unwrap();
+    HttpResponse::Ok().body("DID added.")
 }
 
-async fn manual_hello() -> impl Responder {
-    HttpResponse::Ok().body("Hey there!")
+async fn did_index() -> impl Responder {
+    let dids = list_did().unwrap();
+    HttpResponse::Ok().json(dids)
+}
+
+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")}))
+    );
+    cfg.service(
+        web::resource("/route_did")
+            .route(web::post().to(route_did))
+    );
 }
 
 #[actix_web::main]
 async fn main() -> std::io::Result<()> {
     HttpServer::new(|| {
         App::new()
-            .service(hello)
-            .service(echo)
-            .route("/hey", web::get().to(manual_hello))
+            .service(
+                web::scope("/api").configure(api_config))
     })
-        .bind(("127.0.0.1", 8080))?
+        .bind(("0.0.0.0", 3000))?
         .run()
         .await
 }

did_router/src/schema.rs

@@ -0,0 +1,22 @@
+// @generated automatically by Diesel CLI.
+
+pub mod sql_types {
+    #[derive(diesel::query_builder::QueryId, Clone, diesel::sql_types::SqlType)]
+    #[diesel(postgres_type(name = "did_target_type"))]
+    pub struct DidTargetType;
+}
+
+diesel::table! {
+    use diesel::sql_types::*;
+    use super::sql_types::DidTargetType;
+
+    dids (id) {
+        id -> Int4,
+        #[max_length = 64]
+        did -> Varchar,
+        target_type -> DidTargetType,
+        #[max_length = 512]
+        target -> Nullable<Varchar>,
+        active -> Bool,
+    }
+}