Webクライアントサイドとサーバーサイド両方Rustで書く

// テーブルに保持されている内容に対応するstruct

#[derive(Queryable, Serialize, Deserialize, Debug)]
pub struct Post {
    pub id: i32, // ユニークキー
    pub title: String, // wiki記事のタイトル
    pub body: String, // wiki記事の中身(MarkDown形式)
    pub body_html: String, // wiki記事の中身(bodyから変換したHTML形式)
    pub published: bool, // 公開フラグ。結局今のところ使ってない
}

#[derive(Insertable, AsChangeset, Serialize, Deserialize, Debug)]
#[table_name = "posts"]
pub struct NewPost {
    pub title: String,
    pub body: String,
    pub body_html: String,
    pub published: bool,
}

pub fn show(state: State) -> (State, Response) {
    let res = {
        let path_params = PostPathExtractor::borrow_from(&state);
        let connection = establish_connection();
        let result = posts
            .filter(published.eq(true))
            .find(path_params.id)
            .first::<Post>(&connection);
        match result {
            Ok(post) => {
                let serialized = serde_json::to_string(&post).unwrap();
                create_response(
                    &state,
                    StatusCode::Ok,
                    Some((
                        String::from(serialized).into_bytes(),
                        mime::APPLICATION_JSON,
                    )),
                )
            }
            Err(err) => {
                println!("{:?}", err);
                create_response(
                    &state,
                    StatusCode::NotFound,
                    Some((
                        String::from("{error: not_found}").into_bytes(),
                        mime::APPLICATION_JSON,
                    )),
                )
            }
        }
    };

    (state, res)
}

fn router() -> Router {
    build_simple_router(|route| {
        route.get("/posts/:id").with_path_extractor::<posts_handler::PostPathExtractor>().to(posts_handler::show);
    })
}

pub struct Context {
    pub web: FetchService,
}

impl AsMut<FetchService> for Context {
    fn as_mut(&mut self) -> &mut FetchService {
        &mut self.web
    }
}

pub struct Model {
    ft: Option<FetchTask>,
    post: Option<Post>,
}


pub enum Msg {
    FetchReady(Result<Post, Error>),
    FetchData(i32),
    Ignore,
}


impl<CTX> Component<CTX> for Model
where
    CTX: AsMut<FetchService> + 'static,
{
    type Msg = Msg;
    type Properties = ();

    fn create(_: Self::Properties, _: &mut Env<CTX, Self>) -> Self {
        Model {
            fetching: false,
            post: None,
            ft: None,
            editing: false,
            menu_updated: false,
        }
    }

    fn update(&mut self, msg: Self::Msg, env: &mut Env<CTX, Self>) -> ShouldRender {
        match msg {
            Msg::FetchData(num) => {
                self.fetching = true;
                self.editing = false;
                let callback = env.send_back(|response: Response<Json<Result<Post, Error>>>| {
                    let (meta, Json(data)) = response.into_parts();
                    if meta.status.is_success() {
                        Msg::FetchReady(data)
                    } else {
                        Msg::Ignore // FIXME: Handle this error accordingly.
                    }
                });
                let request = Request::get(format!("http://{}/posts/{}", API_HOSTNAME, num))
                    .body(Nothing)
                    .unwrap();
                let fetch_service: &mut FetchService = env.as_mut();
                let task = fetch_service.fetch(request, callback);
                self.ft = Some(task);
            }
            Msg::FetchReady(response) => {
                self.fetching = false;
                self.editing = false;
                self.menu_updated = true;
                self.post = response.ok();
            }
            Msg::Ignore => {
                let console_service: &mut ConsoleService = env.as_mut();
                self.post = None;
                console_service.log("Ignore");
            }
        }
        true
    }
}

html! {
  <PostForm: post=value.to_new_post(),
  oncancel=|_| Msg::SetEditing(false),
  onsubmit=|new_post| Msg::PutData(new_post),
  />
}

// updateの中
Msg::OnCancel => {
    if let Some(ref mut cb) = self.oncancel {
        cb.emit(());
    }
}
            

// viewの中
<button onclick=|_| Msg::OnCancel,>{ "cancel" }</button>