album/src/main.rs

179 lines
6.1 KiB
Rust
Raw Normal View History

#[macro_use] extern crate nickel;
2015-11-21 18:21:44 +03:00
#[macro_use] extern crate log;
extern crate env_logger;
2015-11-21 18:21:44 +03:00
extern crate rustorm;
extern crate rustc_serialize;
2015-11-22 15:01:39 +03:00
extern crate typemap;
extern crate plugin;
extern crate image;
extern crate hyper;
extern crate time;
mod models;
2015-11-22 15:01:39 +03:00
use hyper::header::{Expires, HttpDate};
use image::open as image_open;
2015-11-29 20:53:09 +03:00
use image::{FilterType, ImageFormat, GenericImage};
use models::{Photo, Tag, Person, Place, query_for};
use nickel::{MediaType, Nickel, StaticFilesHandler};
use plugin::{Pluggable};
use rustc_serialize::Encodable;
use time::Duration;
2015-11-21 18:21:44 +03:00
mod env;
use env::dburl;
2015-11-21 18:21:44 +03:00
mod rustormmiddleware;
use rustormmiddleware::{RustormMiddleware, RustormRequestExtensions};
mod requestloggermiddleware;
use requestloggermiddleware::RequestLoggerMiddleware;
2015-11-22 15:01:39 +03:00
fn get_scaled_image(photo: Photo, width: u32, height: u32) -> Vec<u8> {
let path = format!("/home/kaj/Bilder/foto/{}", photo.path);
info!("Should open {}", path);
let img = image_open(path).unwrap();
2015-11-29 20:53:09 +03:00
let img =
if width < img.width() || height < img.height() {
img.resize(width, height, FilterType::Nearest)
} else {
img
};
let img = match photo.rotation {
_x @ 0...44 => img,
_x @ 45...134 => img.rotate90(),
_x @ 135...224 => img.rotate180(),
_x @ 225...314 => img.rotate270(),
_x @ 315...360 => img,
2015-11-29 20:34:54 +03:00
x => {
warn!("Should rotate photo {} deg, which is unsupported", x);
2015-11-29 20:53:09 +03:00
img
2015-11-29 20:34:54 +03:00
}
};
2015-11-22 15:01:39 +03:00
// TODO Put the icon in some kind of cache!
let mut buf : Vec<u8> = Vec::new();
2015-11-29 20:53:09 +03:00
img.save(&mut buf, ImageFormat::JPEG).unwrap();
2015-11-22 15:01:39 +03:00
buf
}
macro_rules! render {
($res:expr, $template:expr, { $($param:ident : $ptype:ty = $value:expr),* })
=>
{
{
#[derive(Debug, Clone, RustcEncodable)]
struct ParamData {
$(
$param: $ptype,
)*
}
$res.render($template, &ParamData {
$(
$param: $value,
)*
})
}
}
}
fn main() {
env_logger::init().unwrap();
2015-11-21 18:21:44 +03:00
info!("Initalized logger");
let mut server = Nickel::new();
server.utilize(RequestLoggerMiddleware);
2015-11-27 01:20:36 +03:00
server.utilize(StaticFilesHandler::new("static/"));
2015-11-22 15:01:39 +03:00
server.utilize(RustormMiddleware::new(&dburl()));
server.utilize(router! {
2015-11-22 15:01:39 +03:00
get "/" => |req, res| {
return render!(res, "templates/index.tpl", {
photos: Vec<Photo> = query_for::<Photo>()
.filter_gte("grade", &4_i16)
.limit(24)
.collect(req.db_conn()).unwrap()
});
}
2015-11-22 15:01:39 +03:00
get "/details/:id" => |req, res| {
if let Ok(id) = req.param("id").unwrap().parse::<i32>() {
if let Ok(photo) = req.orm_get::<Photo>("id", &id) {
return render!(res, "templates/details.tpl", {
people: Vec<Person> =
req.orm_get_related(&photo, "photo_person").unwrap(),
places: Vec<Place> =
req.orm_get_related(&photo, "photo_place").unwrap(),
tags: Vec<Tag> =
req.orm_get_related(&photo, "photo_tag").unwrap(),
photo: Photo = photo
});
}
}
}
2015-11-27 02:02:18 +03:00
get "/tag/" => |req, res| {
return render!(res, "templates/tags.tpl", {
tags: Vec<Tag> = query_for::<Tag>().asc("tag")
.collect(req.db_conn()).unwrap()
});
2015-11-27 02:02:18 +03:00
}
get "/tag/:tag" => |req, res| {
let slug = req.param("tag").unwrap();
if let Ok(tag) = req.orm_get::<Tag>("slug", &slug) {
return render!(res, "templates/tag.tpl", {
photos: Vec<Photo> =
req.orm_get_related(&tag, "photo_tag").unwrap(),
tag: Tag = tag
2015-11-28 11:53:12 +03:00
});
}
}
get "/person/" => |req, res| {
return render!(res, "templates/people.tpl", {
people: Vec<Person> = query_for::<Person>().asc("name")
.collect(req.db_conn()).unwrap()
});
2015-11-28 11:53:12 +03:00
}
get "/person/:slug" => |req, res| {
let slug = req.param("slug").unwrap();
if let Ok(person) = req.orm_get::<Person>("slug", &slug) {
return render!(res, "templates/person.tpl", {
photos: Vec<Photo> =
req.orm_get_related(&person, "photo_person").unwrap(),
person: Person = person
});
}
}
get "/place/" => |req, res| {
return render!(res, "templates/places.tpl", {
places: Vec<Place> = query_for::<Place>().asc("place")
.collect(req.db_conn()).unwrap()
});
}
get "/place/:slug" => |req, res| {
let slug = req.param("slug").unwrap();
if let Ok(place) = req.orm_get::<Place>("slug", &slug) {
return render!(res, "templates/place.tpl", {
photos: Vec<Photo> =
req.orm_get_related(&place, "photo_place").unwrap(),
place: Place = place
});
}
2015-11-22 15:01:39 +03:00
}
2015-12-06 16:42:03 +03:00
get "/img/:id/:size" => |req, mut res| {
if let Ok(id) = req.param("id").unwrap().parse::<i32>() {
if let Ok(photo) = req.orm_get::<Photo>("id", &id) {
2015-12-06 16:42:03 +03:00
if let Some(size) = match req.param("size").unwrap() {
"s" => Some(200),
"m" => Some(800),
"l" => Some(1200),
_ => None
} {
let buf = get_scaled_image(photo, size, size);
res.set(MediaType::Jpeg);
res.set(Expires(HttpDate(time::now() + Duration::days(14))));
return res.send(buf);
}
}
}
2015-11-22 15:01:39 +03:00
}
});
server.listen("127.0.0.1:6767");
}