rust + mongo

main.rs

extern crate gotham;
extern crate mime;
extern crate mongodb;
extern crate regex;

#[macro_use]
extern crate gotham_derive;
extern crate hyper;
extern crate serde;
#[macro_use]
extern crate serde_derive;
extern crate serde_json;

use gotham::router::builder::*;
use gotham::router::Router;
use gotham::state::{FromState, State};

use mongodb::db::ThreadedDatabase;
use mongodb::{bson, doc, Bson};
use mongodb::{Client, ThreadedClient};

use regex::Regex;
use std::time::{SystemTime, UNIX_EPOCH};

#[derive(Deserialize, StateData, StaticResponseExtender)]
struct QueryStringExtractor {
    issue_id: String,
}

/// Handler function for `GET` requests directed to `/products`
///
/// This handler uses the Serde project when generating responses. You don't need to
/// know about Serde in order to understand the response that is being created here but if you're
/// interested you can learn more at `http://serde.rs`.
fn main_route(mut state: State) -> (State, (mime::Mime, Vec<u8>)) {
    let res = {
        // Access the `QueryStringExtractor` instance from `state` which was put there for us by the
        // `Router` during request evaluation.
        //
        // As well as permitting storage in `State` by deriving `StateData` our query string
        // extractor struct automatically gains the `take_from` method and a number of other
        // methods via the `gotham::state::FromState` trait.
        //
        // n.b. Once taken out of `state` values can no longer be accessed by other application
        // code or middlewares.
        let query_param = QueryStringExtractor::take_from(&mut state);

        let client =
            Client::connect("127.0.0.1", 27017).expect("Failed to initialize standalone client.");

        let coll = client.db("db").collection("col");

        let start = SystemTime::now();
        let since_the_epoch = start
            .duration_since(UNIX_EPOCH)
            .expect("Time went backwards");

        let doc = doc! {
            "end_date_unix": {
                "$gte": since_the_epoch.as_secs()
            },
            "_id": mongodb::oid::ObjectId::with_string(&query_param.issue_id).unwrap()
        };

        let cursor = coll
            .find(Some(doc.clone()), None)
            .ok()
            .expect("Failed to execute find.");

        // let mut v: Vec<Vec<i32>> = Vec::new();
        let mut final_result: Vec<Vec<i64>> = Vec::new();

        let mut temp_vec = [0, 0];
        let remove_leading_space = Regex::new(r"(^[\s])").unwrap();
        let social_media = ["facebook", "twitter", "instagram", "youtube"];
        for result in cursor {
            if let Ok(item) = result {
                if let Some(&Bson::String(ref keywords)) = item.get("keyword") {
                    for socmed in social_media.iter() {
                        let mut smd_col = "";

                        let issue_keyword: Vec<&str> = keywords.split(',').collect();

                        for keyword in issue_keyword {
                            let mut used_keyword =
                                remove_leading_space.replace(keyword, "").to_string();
                            match socmed {
                                &"facebook" => { // useless for now
                                    smd_col = "facebook_xxx";
                                }
                                &"twitter" => {
                                    smd_col = "twitter_xxx";
                                }
                                &"instagram" => {
                                    smd_col = "instagram_xxx";
                                    let re = Regex::new(r"([\s])").unwrap();
                                    used_keyword = re.replace_all(keyword, "").to_string()
                                }
                                &"youtube" => {
                                    smd_col = "youtube_xxx";
                                }
                                _ => smd_col = "",
                            }

                            if smd_col != "" {
                                let doc_find = doc!{
                                    "user_query": used_keyword
                                };

                                println!("{:?}", doc_find);
                                println!("{:?}", smd_col);

                                let coll = client.db("db").collection(smd_col);

                                let smd_cursor = coll
                                    .find(Some(doc_find.clone()), None)
                                    .ok()
                                    .expect("Failed to execute find.");

                                for post in smd_cursor {
                                    if let Ok(item) = post {
                                        println!("{:?}", item.get("sentiment"));
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }

        let response = [12];

        (
            mime::APPLICATION_JSON,
            serde_json::to_vec(&response).expect("serialized"),
        )
    };
    (state, res)
}

/// Create a `Router`
fn router() -> Router {
    build_simple_router(|route| {
        route
            .get("/ss")
            // This tells the Router that for requests which match this route that query string
            // extraction should be invoked storing the result in a `QueryStringExtractor` instance.
            .with_query_string_extractor::<QueryStringExtractor>()
            .to(main_route);
    })
}

/// Start a server and call the `Handler` we've defined above for each `Request` we receive.
pub fn main() {
    let addr = "127.0.0.1:7878";

    println!("Listening for requests at http://{}", addr);
    gotham::start(addr, router())
}