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

//! `/import` related routes

extern crate zip;

use super::super::Pool;
use super::super::PostgresConnectionManager;
use super::super::RoutesHandler;

use super::super::Json;
use super::super::State;
use super::model_api::successresult::SuccessResult;

use self::zip::ZipArchive;
use super::super::super::importer;
use std::fs::File;
use std::thread;

#[get("/import/url/<feed_url>")]
pub fn url(rh: State<RoutesHandler>, feed_url: String) -> Json<SuccessResult> {
    let pool: Pool<PostgresConnectionManager> = rh.pool.clone();
    thread::spawn(move || {
        //importer::create_tables(&pool);
        let zar = importer::download_feed_zip(&feed_url, &pool);
        if zar.is_some() {
            let mut zar = zar.unwrap();
            importer::parse_feed_zip(&mut zar, &pool)
        } else {
            println!("Unable to get the feed zip");
        }
    });
    let sr = SuccessResult { success: true };
    Json(sr)
}

#[get("/import/fs/<file_name>")]
pub fn fs(rh: State<RoutesHandler>, file_name: String) -> Json<SuccessResult> {
    let pool: Pool<PostgresConnectionManager> = rh.pool.clone();
    thread::spawn(move || {
        //importer::create_tables(&pool);
        importer::parse_feed_zip(
            &mut ZipArchive::new(File::open("resources/gtfs/flixbus/flixbus.zip").unwrap())
                .unwrap(),
            &pool,
        );
    });
    let sr = SuccessResult { success: true };
    Json(sr)
}

#[get("/import/agency/<feed_id>")]
pub fn agency(rh: State<RoutesHandler>, feed_id: String) -> Json<SuccessResult> {
    let pool: Pool<PostgresConnectionManager> = rh.pool.clone();
    thread::spawn(move || {
        importer::create_tables(&pool);
        //importer::parse_agency(&feed_id, "./resources/gtfs/sbb/agency.txt", &pool);
        println!("Agency parsed!");
    });
    let sr = SuccessResult { success: true };
    Json(sr)
}

#[get("/import/stops/<feed_id>")]
pub fn stops(rh: State<RoutesHandler>, feed_id: String) -> Json<SuccessResult> {
    let pool: Pool<PostgresConnectionManager> = rh.pool.clone();
    thread::spawn(move || {
        importer::create_tables(&pool);
        //importer::parse_stops(&feed_id, "./resources/gtfs/sbb/stops.txt", &pool);
        println!("Stops parsed!");
    });
    let sr = SuccessResult { success: true };
    Json(sr)
}

#[get("/import/times/<feed_id>")]
pub fn times(rh: State<RoutesHandler>, feed_id: String) -> Json<SuccessResult> {
    let pool: Pool<PostgresConnectionManager> = rh.pool.clone();
    thread::spawn(move || {
        importer::create_tables(&pool);
        //importer::parse_stop_times(&feed_id, "./resources/gtfs/sbb/stop_times.txt", &pool);
        println!("Stop Times parsed!");
    });
    let sr = SuccessResult { success: true };
    Json(sr)
}

#[get("/import/routes/<feed_id>")]
pub fn routes(rh: State<RoutesHandler>, feed_id: String) -> Json<SuccessResult> {
    let pool: Pool<PostgresConnectionManager> = rh.pool.clone();
    thread::spawn(move || {
        importer::create_tables(&pool);
        //importer::parse_routes(&feed_id, "./resources/gtfs/sbb/routes.txt", &pool);
        println!("Routes parsed!");
    });
    let sr = SuccessResult { success: true };
    Json(sr)
}

#[get("/import/trips/<feed_id>")]
pub fn trips(rh: State<RoutesHandler>, feed_id: String) -> Json<SuccessResult> {
    let pool: Pool<PostgresConnectionManager> = rh.pool.clone();
    thread::spawn(move || {
        importer::create_tables(&pool);
        //importer::parse_trips(&feed_id, "./resources/gtfs/sbb/trips.txt", &pool);
        println!("Trips parsed!");
    });
    let sr = SuccessResult { success: true };
    Json(sr)
}

#[get("/import/calendar/<feed_id>")]
pub fn calendar(rh: State<RoutesHandler>, feed_id: String) -> Json<SuccessResult> {
    let pool: Pool<PostgresConnectionManager> = rh.pool.clone();
    thread::spawn(move || {
        importer::create_tables(&pool);
        //importer::parse_calendar(&feed_id, "./resources/gtfs/sbb/calendar.txt", &pool);
        println!("Calendar parsed!");
    });
    let sr = SuccessResult { success: true };
    Json(sr)
}