#[charybdis_model(
    table_name = users,
    partition_keys = [id],
    clustering_keys = [],
    global_secondary_indexes = [username],
)]
#[derive(Serialize, Deserialize, Default, Clone, Debug)]
#[serde(rename_all = "camelCase")]
pub struct User {
    #[serde(default = "Uuid::new_v4")]
    pub id: Uuid,
    pub username: Text,
    pub email: Text,
    pub password: Text,
    pub first_name: Text,
    pub last_name: Text,
    pub bio: Option<Text>,
    pub address: Option<Address>,
    #[serde(default = "chrono::Utc::now")]
    pub created_at: Timestamp,
    #[serde(default = "chrono::Utc::now")]
    pub updated_at: Timestamp,
}

impl Callbacks for User {
    type Extension = ();
    type Error = AppError;

    async fn before_insert(
        &mut self,
        _session: &CachingSession,
        _extension: &Self::Extension,
    ) -> Result<(), Self::Error> {
        self.id = Uuid::new_v4();
        self.created_at = chrono::Utc::now();
        self.updated_at = chrono::Utc::now();
        Ok(())
    }
}

cargo install charybdis-migrate

migrate --hosts <host> --keyspace <your_keyspace> --drop-and-replace

pub async fn basic_queries(session: &CachingSession) -> Result<(), AppError> {
    let mut user = User::default();
    user.insert_cb(&()).execute(session).await?;
    user.username = "test".to_string();
    user.update_cb(&()).execute(session).await?;
    let user = User::find_by_id(user.id).execute(session).await?;
    let user_by_username = User::find_by_username(user.username)
        .consistency(charybdis::options::Consistency::All)
        .execute(session)
        .await?;
    let maybe_user: Option<User> = User::maybe_find_first_by_id(user.id).execute(session).await?;
    Ok(())
}

#[charybdis_model(
    table_name = communities,
    partition_keys = [id],
    clustering_keys = [],
    global_secondary_indexes = [],
)]
#[derive(Serialize, Deserialize, Default, Clone)]
#[serde(rename_all = "camelCase")]
pub struct Community {
    pub id: Uuid,
    pub title: Text,
    pub description: Text,
    pub created_at: Timestamp,
    pub updated_at: Timestamp,
    pub creator_id: Uuid,
    pub creator: Profile,
}

#[charybdis_model(
    table_name = posts,
    partition_keys = [community_id],
    clustering_keys = [created_at, id],
    global_secondary_indexes = [],
)]
#[derive(Serialize, Deserialize, Default, Clone, Debug)]
#[serde(rename_all = "camelCase")]
#[serde(default)]
pub struct Post {
    pub community_id: Uuid,
    pub created_at: Timestamp,
    pub id: Uuid,
    pub title: Text,
    pub description: Text,
    pub updated_at: Timestamp,
    pub creator_id: Uuid,
    pub creator: Profile,
    pub is_archived: bool,
}

#[post("")]
pub async fn create_post(
    db_session: web::Data<CachingSession>,
    mut post: web::Json<Post>,
) -> Result<HttpResponse, AppError> {
    post.insert_cb(&()).execute(&db_session).await?;
    Ok(HttpResponse::Created().json(post))
}

partial_post!(
    UpdateDescriptionPost, 
    community_id, created_at, updated_at, id, description
);

impl Callbacks for UpdateDescriptionPost {
    type Extension = ();
    type Error = AppError;

    async fn before_update(&mut self, _: &CachingSession, _: &Self::Extension) -> Result<(), AppError> {
        self.updated_at = chrono::Utc::now();
        Ok(())
    }
}

#[put("/update_description")]
pub async fn update_post_description(
    db_session: web::Data<CachingSession>,
    post: web::Json<UpdateDescriptionPost>,
) -> Result<HttpResponse, AppError> {
    let mut post = post.into_inner();
    post.update_cb(&()).execute(&db_session).await?;
    Ok(HttpResponse::Ok().json(post))
}