album/src/main.rs

#[macro_use]
extern crate nickel;
#[macro_use]
extern crate log;
extern crate env_logger;
extern crate nickel_jwt_session;
extern crate rustorm;
extern crate rustc_serialize;
extern crate typemap;
extern crate plugin;
extern crate image;
extern crate hyper;
extern crate time;
extern crate chrono;
extern crate rexif;

use chrono::UTC;
use chrono::offset::TimeZone;
use chrono::Duration as ChDuration;
use chrono::Datelike;
use hyper::header::{Expires, HttpDate};
use nickel::{FormBody, HttpRouter, MediaType, MiddlewareResult, Nickel,
             Request, Response, StaticFilesHandler};
use nickel::extensions::response::Redirect;
use nickel_jwt_session::{SessionMiddleware, SessionRequestExtensions,
                         SessionResponseExtensions};
use plugin::Pluggable;
use rustc_serialize::Encodable;
use rustorm::query::{Filter, Query};
use time::Duration;
use nickel::status::StatusCode;
use std::collections::HashMap;

mod models;
use models::{Entity, Person, Photo, PhotoQuery, Place, Tag, query_for};

mod env;
use env::{dburl, env_or, jwt_key, photos_dir};

mod photosdir;

mod rustormmiddleware;
use rustormmiddleware::{RustormMiddleware, RustormRequestExtensions};

mod requestloggermiddleware;
use requestloggermiddleware::RequestLoggerMiddleware;

mod photosdirmiddleware;
use photosdirmiddleware::{PhotosDirMiddleware, PhotosDirRequestExtensions};


macro_rules! render {
    ($res:expr, $template:expr, { $($param:ident : $ptype:ty = $value:expr),* })
        =>
    {
        {
        #[derive(Debug, Clone, RustcEncodable)]
        struct ParamData {
            csslink: String,
            $(
                $param: $ptype,
                )*
        }
        $res.render($template, &ParamData {
            csslink: include!(concat!(env!("OUT_DIR"), "/stylelink")).into(),
            $(
                $param: $value,
                )*
        })
        }
    }
}

fn orm_get_related<T: Entity, Src: Entity>(src: &Src,
                                           rel_table: &str)
                                           -> Query {
    let mut q = Query::select();
    q.only_from(&T::table());
    q.left_join_table(rel_table,
                      &format!("{}.id", T::table().name),
                      &format!("{}.{}", rel_table, T::table().name))
     .filter_eq(&format!("{}.{}", rel_table, Src::table().name), src.id());
    q
}

#[derive(Debug, Clone, RustcEncodable)]
struct Group {
    title: String,
    url: String,
    count: i64,
    photo: Photo,
}

fn monthname(n: u8) -> &'static str {
    match n {
        1 => "january",
        2 => "february",
        3 => "march",
        4 => "april",
        5 => "may",
        6 => "june",
        7 => "july",
        8 => "august",
        9 => "september",
        10 => "october",
        11 => "november",
        12 => "december",
        _ => "non-month",
    }
}

fn main() {
    env_logger::init().unwrap();
    info!("Initalized logger");

    let mut server = Nickel::new();
    server.utilize(RequestLoggerMiddleware);
    server.utilize(SessionMiddleware::new(&jwt_key()));
    // TODO This is a "build" location, not an "install" location ...
    let staticdir = concat!(env!("OUT_DIR"), "/static/");
    info!("Serving static files from {}", staticdir);
    server.utilize(StaticFilesHandler::new(staticdir));
    server.utilize(RustormMiddleware::new(&dburl()));
    server.utilize(PhotosDirMiddleware::new(photos_dir()));

    server.get("/login",             login);
    server.post("/login",            do_login);
    server.get("/logout",            logout);
    server.get("/",                  all_years);
    server.get("/img/:id/:size",     show_image);
    server.get("/tag/",              tag_all);
    server.get("/tag/:tag",          tag_one);
    server.get("/place/",            place_all);
    server.get("/place/:slug",       place_one);
    server.get("/person/",           person_all);
    server.get("/person/:slug",      person_one);
    server.get("/details/:id",       photo_details);
    server.get("/:year/",            months_in_year);
    server.get("/:year/:month/",     days_in_month);
    server.get("/:year/:month/:day", all_for_day);

    server.listen(&*env_or("RPHOTOS_LISTEN", "127.0.0.1:6767"));
}

fn login<'mw>(_req: &mut Request,
              mut res: Response<'mw>)
              -> MiddlewareResult<'mw> {
    res.clear_jwt_user();
    render!(res, "templates/login.tpl", {})
}

fn do_login<'mw>(req: &mut Request,
                 mut res: Response<'mw>)
                 -> MiddlewareResult<'mw> {
    let form_data = try_with!(res, req.form_body());
    if let (Some(user), Some(password)) = (form_data.get("user"),
                                           form_data.get("password")) {
        // TODO Actual password hashing and checking
        if user == "kaj" && password == "kaj123" {
            res.set_jwt_user(user);
            return res.redirect("/");
        }
    }
    render!(res, "templates/login.tpl", {})
}

fn logout<'mw>(_req: &mut Request,
               mut res: Response<'mw>)
               -> MiddlewareResult<'mw> {
    res.clear_jwt_user();
    res.redirect("/")
}

fn show_image<'mw>(req: &mut Request,
                   mut res: Response<'mw>)
                   -> MiddlewareResult<'mw> {
    if let Ok(id) = req.param("id").unwrap().parse::<i32>() {
        if let Ok(photo) = req.orm_get::<Photo>("id", &id) {
            if req.authorized_user().is_some() || photo.is_public() {
                if let Some(size) = match req.param("size").unwrap() {
                    "s" => Some(200),
                    "m" => Some(800),
                    "l" => Some(1200),
                    _ => None,
                } {
                    match req.photos().get_scaled_image(photo, size, size) {
                        Ok(buf) => {
                            res.set(MediaType::Jpeg);
                            res.set(Expires(HttpDate(time::now() +
                                                     Duration::days(14))));
                            return res.send(buf);
                        }
                        Err(err) => {
                            return res.error(StatusCode::InternalServerError,
                                             format!("{}", err));
                        }
                    }
                }
            }
        }
    }
    res.error(StatusCode::NotFound, "No such image")
}

fn tag_all<'mw>(req: &mut Request,
                res: Response<'mw>)
                -> MiddlewareResult<'mw> {
    return render!(res, "templates/tags.tpl", {
        user: Option<String> = req.authorized_user(),
        tags: Vec<Tag> = query_for::<Tag>().asc("tag")
            .collect(req.db_conn()).unwrap()
    });
}
fn tag_one<'mw>(req: &mut Request,
                res: Response<'mw>)
                -> MiddlewareResult<'mw> {
    let slug = req.param("tag").unwrap();
    if let Ok(tag) = req.orm_get::<Tag>("slug", &slug) {
        return render!(res, "templates/tag.tpl", {
            user: Option<String> = req.authorized_user(),
            photos: Vec<Photo> =
                orm_get_related::<Photo, Tag>(&tag, "photo_tag")
                .only_public(req.authorized_user().is_none())
                .desc_nulls_last("grade")
                .desc_nulls_last("date")
                .collect(req.db_conn()).unwrap(),
            tag: Tag = tag
        });
    }
    res.error(StatusCode::NotFound, "Not a tag")
}

fn place_all<'mw>(req: &mut Request,
                  res: Response<'mw>)
                  -> MiddlewareResult<'mw> {
    return render!(res, "templates/places.tpl", {
        user: Option<String> = req.authorized_user(),
        places: Vec<Place> = query_for::<Place>().asc("place")
            .collect(req.db_conn()).unwrap()
    });
}
fn place_one<'mw>(req: &mut Request,
                  res: Response<'mw>)
                  -> MiddlewareResult<'mw> {
    let slug = req.param("slug").unwrap();
    if let Ok(place) = req.orm_get::<Place>("slug", &slug) {
        return render!(res, "templates/place.tpl", {
            user: Option<String> = req.authorized_user(),
            photos: Vec<Photo> =
                orm_get_related::<Photo, Place>(&place, "photo_place")
                .only_public(req.authorized_user().is_none())
                .desc_nulls_last("grade")
                .desc_nulls_last("date")
                .collect(req.db_conn()).unwrap(),
            place: Place = place
        });
    }
    res.error(StatusCode::NotFound, "Not a place")
}

fn person_all<'mw>(req: &mut Request,
                   res: Response<'mw>)
                   -> MiddlewareResult<'mw> {
    return render!(res, "templates/people.tpl", {
        user: Option<String> = req.authorized_user(),
        people: Vec<Person> = query_for::<Person>().asc("name")
            .collect(req.db_conn()).unwrap()
    });
}
fn person_one<'mw>(req: &mut Request,
                   res: Response<'mw>)
                   -> MiddlewareResult<'mw> {
    let slug = req.param("slug").unwrap();
    if let Ok(person) = req.orm_get::<Person>("slug", &slug) {
        return render!(res, "templates/person.tpl", {
            user: Option<String> = req.authorized_user(),
            photos: Vec<Photo> =
                orm_get_related::<Photo, Person>(&person, "photo_person")
                .only_public(req.authorized_user().is_none())
                .desc_nulls_last("grade")
                .desc_nulls_last("date")
                .collect(req.db_conn()).unwrap(),
            person: Person = person
        });
    }
    res.error(StatusCode::NotFound, "Not a place")
}

fn photo_details<'mw>(req: &mut Request,
                      res: Response<'mw>)
                      -> MiddlewareResult<'mw> {
    if let Ok(id) = req.param("id").unwrap().parse::<i32>() {
        if let Ok(photo) = req.orm_get::<Photo>("id", &id) {
            if req.authorized_user().is_some() || photo.is_public() {
                return render!(res, "templates/details.tpl", {
                    user: Option<String> = req.authorized_user(),
                    monthlink: HashMap<String, String> =
                        photo.date
                             .map(|d| month_link(d.year(), d.month() as u8))
                             .unwrap_or_else(|| HashMap::new()),
                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(),
                time: String = match photo.date {
                    Some(d) => d.format("%T").to_string(),
                    None => "".to_string()
                },
                year: Option<i32> = photo.date.map(|d| d.year()),
                month: Option<u32> = photo.date.map(|d| d.month()),
                day: Option<u32> = photo.date.map(|d| d.day()),
                photo: Photo = photo
                });
            }
        }
    }
    res.error(StatusCode::NotFound, "Not a year")
}

fn all_years<'mw>(req: &mut Request,
                  res: Response<'mw>)
                  -> MiddlewareResult<'mw> {
    return render!(res, "templates/groups.tpl", {
        user: Option<String> = req.authorized_user(),
        title: &'static str = "All photos",
        groups: Vec<Group> = query_for::<Photo>()
            .columns(vec!("extract(year from date) y", "count(*) c"))
            .only_public(req.authorized_user().is_none())
            .add_filter(Filter::is_not_null("date"))
            .group_by(vec!("y")).asc("y")
            .retrieve(req.db_conn()).expect("Get images per year")
            .dao.iter().map(|dao| {
                debug!("Got a pregroup: {:?}", dao);
                let year = dao.get::<f64>("y") as u16;
                let count : i64 = dao.get("c");
                let photo : Photo = query_for::<Photo>()
                    .only_public(req.authorized_user().is_none())
                    .filter_date("date", "year", year as u32)
                    .desc_nulls_last("grade")
                    .asc_nulls_last("date")
                    .limit(1)
                    .collect_one(req.db_conn()).unwrap();
                Group {
                    title: format!("{}", year),
                    url: format!("/{}/", year),
                    count: count,
                    photo: photo
                }
            }).collect()
    });
}

fn months_in_year<'mw>(req: &mut Request,
                       res: Response<'mw>)
                       -> MiddlewareResult<'mw> {
    if let Ok(year) = req.param("year").unwrap().parse::<i32>() {
        return render!(res, "templates/groups.tpl", {
            user: Option<String> = req.authorized_user(),
            title: String = format!("Photos from {}", year),
            groups: Vec<Group> = query_for::<Photo>()
                .only_public(req.authorized_user().is_none())
                .columns(vec!("extract(month from date) m", "count(*) c"))
                .filter_date("date", "year", year as u32)
                .group_by(vec!("m")).asc("m")
                .retrieve(req.db_conn()).expect("Get images per month")
                .dao.iter().map(|dao| {
                    let month = dao.get::<f64>("m") as u8;
                    let count : i64 = dao.get("c");
                    let photo : Photo = query_for::<Photo>()
                        .only_public(req.authorized_user().is_none())
                        .filter_date("date", "year", year as u32)
                        .filter_date("date", "month", month as u32)
                        .desc_nulls_last("grade")
                        .asc_nulls_last("date")
                        .limit(1)
                        .collect_one(req.db_conn()).unwrap();
                    Group {
                        title: monthname(month).to_string(),
                        url: format!("/{}/{}/", year, month),
                        count: count,
                        photo: photo
                    }
                }).collect()
        });
    }
    res.error(StatusCode::NotFound, "Not a year")
}

fn days_in_month<'mw>(req: &mut Request,
                      res: Response<'mw>)
                      -> MiddlewareResult<'mw> {
    if let Ok(year) = req.param("year").unwrap().parse::<i32>() {
        if let Ok(month) = req.param("month").unwrap().parse::<u8>() {
            return render!(res, "templates/groups.tpl", {
                user: Option<String> = req.authorized_user(),
                year: Option<i32> = Some(year),
                title: String = format!("Photos from {} {}", monthname(month),
                                        year),
                groups: Vec<Group> = query_for::<Photo>()
                    .only_public(req.authorized_user().is_none())
                    .columns(vec!("extract(day from date) d", "count(*) c"))
                    .filter_date("date", "year", year as u32)
                    .filter_date("date", "month", month as u32)
                    .group_by(vec!("d")).asc("d")
                    .retrieve(req.db_conn()).expect("Get images per day")
                    .dao.iter().map(|dao| {
                        let day = dao.get::<f64>("d") as u8;
                        let count : i64 = dao.get("c");
                        let photo = query_for::<Photo>()
                            .only_public(req.authorized_user().is_none())
                            .filter_date("date", "year", year as u32)
                            .filter_date("date", "month", month as u32)
                            .filter_date("date", "day", day as u32)
                            .desc_nulls_last("grade")
                            .asc_nulls_last("date")
                            .limit(1)
                            .collect_one(req.db_conn()).unwrap();
                        Group {
                            title: format!("{}/{}", day, month),
                            url: format!("/{}/{}/{}", year, month, day),
                            count: count,
                            photo: photo
                        }
                    }).collect()
            });
        }
    }
    res.error(StatusCode::NotFound, "Not a month")
}

fn all_for_day<'mw>(req: &mut Request,
                    res: Response<'mw>)
                    -> MiddlewareResult<'mw> {
    if let Ok(year) = req.param("year").unwrap().parse::<i32>() {
        if let Ok(month) = req.param("month").unwrap().parse::<u8>() {
            if let Ok(day) = req.param("day").unwrap().parse::<u32>() {
                let date = UTC.ymd(year, month as u32, day).and_hms(0, 0, 0);
                return render!(res, "templates/index.tpl", {
                    user: Option<String> = req.authorized_user(),
                    year: Option<i32> = Some(year),
                    monthlink: HashMap<String, String> =
                        month_link(year, month),
                    title: String = format!("Photos from {} {} {}",
                                            day, monthname(month), year),
                    photos: Vec<Photo> = query_for::<Photo>()
                        .only_public(req.authorized_user().is_none())
                        .filter_gte("date", &date)
                        .filter_lt("date", &(date + ChDuration::days(1)))
                        .desc_nulls_last("grade")
                        .asc_nulls_last("date")
                        .collect(req.db_conn()).unwrap()
                });
            }
        }
    }
    res.error(StatusCode::NotFound, "Not a day")
}

fn month_link(year: i32, month: u8) -> HashMap<String, String> {
    let mut ml = HashMap::new();
    ml.insert("url".to_string(), format!("/{}/{}/", year, month));
    ml.insert("name".to_string(), format!("{}", month));
    ml
}