1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
|
//! This module contains the implementation of converse's actix-web
//! HTTP handlers.
//!
//! Most handlers have an associated rendering function using one of
//! the tera templates stored in the `/templates` directory in the
//! project root.
use actix::prelude::{Addr, Syn};
use actix_web;
use actix_web::*;
use actix_web::middleware::{Started, Middleware, RequestSession};
use db::*;
use errors::{Result, ConverseError};
use futures::Future;
use models::*;
use oidc::*;
use tera;
type ConverseResponse = Box<Future<Item=HttpResponse, Error=ConverseError>>;
/// Represents the state carried by the web server actors.
pub struct AppState {
/// Address of the database actor
pub db: Addr<Syn, DbExecutor>,
/// Address of the OIDC actor
pub oidc: Addr<Syn, OidcExecutor>,
/// Compiled templates
pub tera: tera::Tera,
}
/// This function renders an overview of threads into the default
/// thread list template.
fn render_threads(tpl: &tera::Tera, threads: Vec<Thread>) -> Result<HttpResponse> {
let mut ctx = tera::Context::new();
ctx.add("threads", &threads);
let body = tpl.render("index.html", &ctx)?;
Ok(HttpResponse::Ok().content_type("text/html").body(body))
}
pub fn forum_index(state: State<AppState>) -> ConverseResponse {
state.db.send(ListThreads)
.from_err()
.and_then(move |res| match res {
Ok(threads) => Ok(render_threads(&state.tera, threads)?),
Err(err) => {
error!("Error loading threads: {}", err);
Ok(HttpResponse::InternalServerError().into())
}
})
.responder()
}
/// This function renders a single forum thread into the default
/// thread view.
fn render_thread(tpl: &tera::Tera, thread: Thread, posts: Vec<Post>)
-> Result<HttpResponse> {
let mut ctx = tera::Context::new();
ctx.add("thread", &thread);
ctx.add("posts", &posts);
let body = tpl.render("thread.html", &ctx)?;
Ok(HttpResponse::Ok()
.content_type("text/html")
.body(body))
}
/// This handler retrieves and displays a single forum thread.
pub fn forum_thread(state: State<AppState>, thread_id: Path<i32>) -> ConverseResponse {
let id = thread_id.into_inner();
state.db.send(GetThread(id))
.from_err()
.and_then(move |res| match res {
Ok((thread, posts)) => Ok(render_thread(&state.tera, thread, posts)?),
Err(err) => {
error!("Error loading thread {}: {}", id, err);
Ok(HttpResponse::InternalServerError().into())
}
})
.responder()
}
#[derive(Deserialize)]
pub struct NewThreadForm {
pub title: String,
pub body: String,
}
/// This handler receives a "New thread"-form and redirects the user
/// to the new thread after creation.
pub fn submit_thread(state: State<AppState>,
input: Form<NewThreadForm>,
mut req: HttpRequest<AppState>) -> ConverseResponse {
// Author is "unwrapped" because the RequireLogin middleware
// guarantees it to be present.
let author: Author = req.session().get(AUTHOR).unwrap().unwrap();
let new_thread = NewThread {
title: input.0.title,
body: input.0.body,
author_name: author.name,
author_email: author.email,
};
state.db.send(CreateThread(new_thread))
.from_err()
.and_then(move |res| {
let thread = res?;
info!("Created new thread \"{}\" with ID {}", thread.title, thread.id);
Ok(HttpResponse::SeeOther()
.header("Location", format!("/thread/{}", thread.id))
.finish())
})
.responder()
}
#[derive(Deserialize)]
pub struct NewPostForm {
pub thread_id: i32,
pub body: String,
}
/// This handler receives a "Reply"-form and redirects the user to the
/// new post after creation.
pub fn reply_thread(state: State<AppState>,
input: Form<NewPostForm>,
mut req: HttpRequest<AppState>) -> ConverseResponse {
// Author is "unwrapped" because the RequireLogin middleware
// guarantees it to be present.
let author: Author = req.session().get(AUTHOR).unwrap().unwrap();
let new_post = NewPost {
thread_id: input.thread_id,
body: input.0.body,
author_name: author.name,
author_email: author.email,
};
state.db.send(CreatePost(new_post))
.from_err()
.and_then(move |res| {
let post = res?;
info!("Posted reply {} to thread {}", post.id, post.thread_id);
Ok(HttpResponse::SeeOther()
.header("Location", format!("/thread/{}#post{}", post.thread_id, post.id))
.finish())
})
.responder()
}
/// This handler initiates an OIDC login.
pub fn login(state: State<AppState>) -> ConverseResponse {
state.oidc.send(GetLoginUrl)
.from_err()
.and_then(|url| Ok(HttpResponse::TemporaryRedirect()
.header("Location", url)
.finish()))
.responder()
}
const AUTHOR: &'static str = "author";
pub fn callback(state: State<AppState>,
data: Form<CodeResponse>,
mut req: HttpRequest<AppState>) -> ConverseResponse {
state.oidc.send(RetrieveToken(data.0))
.from_err()
.and_then(move |result| {
let author = result?;
info!("Setting cookie for {} after callback", author.name);
req.session().set(AUTHOR, author)?;
Ok(HttpResponse::SeeOther()
.header("Location", "/")
.finish())})
.responder()
}
/// Middleware used to enforce logins unceremonially.
pub struct RequireLogin;
impl <S> Middleware<S> for RequireLogin {
fn start(&self, req: &mut HttpRequest<S>) -> actix_web::Result<Started> {
let has_author = req.session().get::<Author>(AUTHOR)?.is_some();
let is_oidc_req = req.path().starts_with("/oidc");
if !is_oidc_req && !has_author {
Ok(Started::Response(
HttpResponse::SeeOther()
.header("Location", "/oidc/login")
.finish()
))
} else {
Ok(Started::Done)
}
}
}
|
