freeswitch_chris/did_router/src/database.rs

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;
use std::str::FromStr;
use strum_macros::EnumString;

#[derive(Debug, PartialEq, DbEnum, Serialize, EnumString)]
#[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(Debug, 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_number: 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_number: &'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 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 get_did_by(did: &str) -> Result<Did, Error> {
    use crate::schema::dids::dsl::*;
    let mut conn = connect();

    let d = dids.filter(did_number.eq(did))
        .first::<Did>(&mut conn)?;

    Ok(d)
}

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_number: did_number,
        target_type: DidTargetType::from_str(target_type).unwrap(),
        target: Some(target),
        active: active
    };

    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)
}