table! {
    active_user (id) {
        id -> Int4,
        user_name -> Varchar,
    }
}
 
table! {
    adjective (id) {
        id -> Int4,
        adjective_value -> Varchar,
    }
}
 
table! {
    user_adjective (id) {
        id -> Int4,
        user_id -> Int4,
        adjective_id -> Int4,
        count -> Nullable<Int4>,
    }
}
 
allow_tables_to_appear_in_same_query!(
    active_user,
    adjective,
    user_adjective,
);

#[derive(Clone, Queryable, Serialize, Deserialize, FromForm)]
pub struct User {
    pub id : i32,
    pub user_name : String,
}

#[derive(Clone, Queryable, Serialize, Deserialize, FromForm)]

use diesel::pg::PgConnection;
use r2d2;
use r2d2_diesel::ConnectionManager;
use std::env;
 
type Pool = r2d2::Pool<ConnectionManager<PgConnection>>;
 
pub fn init_pool() -> Pool {
    dotenv().ok();
    let manager = ConnectionManager::<PgConnection>::new(database_url());
    Pool::new(manager).expect("Cannot initialize db pool")
}
 
fn database_url() -> String {
    env::var("DATABASE_URL").expect("DATABASE_URL must be set")
}

use diesel;
use diesel::{ pg::PgConnection
              , RunQueryDsl
              , prelude::*
};
use database::schema::*;
use database::models::{ user::User
                        , adjective::Adjective
                        , user_adjective::{ UserAdjective
                                            , NewUsAdRecord }
};
use failure::Error;
 
pub fn all_users(connection: &PgConnection) -> QueryResult<Vec<User>> {
    active_user::table.load::<User>(&*connection)
}
 
pub fn all_adjectives(connection: &PgConnection) -> QueryResult<Vec<Adjective>> {
    adjective::table.load::<Adjective>(&*connection)
}
 
pub fn get_user_by_id(connection : &PgConnection, id : &i32) -> QueryResult<User> {
    active_user::table
        .find(id)
        .get_result::<User>(connection)
}
 
pub fn get_user_by_name(connection : &PgConnection, name : &str) -> QueryResult<User> {
    active_user::table
        .filter(active_user::user_name.eq(name))
        .get_result(connection)
}
 
pub fn get_adjective_by_id(connection : &PgConnection, id : &i32) -> QueryResult<Adjective> {
    adjective::table
        .find(id)
        .get_result::<Adjective>(connection)
}
 
pub fn get_adjective_by_name(connection : &PgConnection, name : &str) -> QueryResult<Adjective> {
    adjective::table
        .filter(adjective::adjective_value.eq(name))
        .get_result(connection)
}
 
pub fn get_top10_all(conn : &PgConnection) -> Result<Vec<UserAdjective>, Error> {
    let query = user_adjective::table
        .order(user_adjective::user_id)
        .order(user_adjective::count.desc())
        .limit(10);
 
    let us_adj = query.load::<UserAdjective>(conn)?;
 
    Ok(us_adj)
}
 
pub fn get_count_of_repeats(conn : &PgConnection, user_id : &i32, adjective_id : &i32) -> Result<Vec<UserAdjective>, Error> {
    let query = user_adjective::table
        .filter(user_adjective::user_id.eq(user_id))
        .filter(user_adjective::adjective_id.eq(adjective_id));
 
    let us_adj = query.load::<UserAdjective>(conn)?;
 
    Ok(us_adj)
}
 
 
pub fn get_count(conn : &PgConnection, user : &User, adjective : &Adjective) -> Result<Vec<UserAdjective>, Error> {
    let query = user_adjective::table
        .filter(user_adjective::user_id.eq(user.id))
        .filter(user_adjective::adjective_id.eq(adjective.id));
 
    let us_adj = query.load::<UserAdjective>(conn)?;
 
    Ok(us_adj)
}
 
 
pub fn update_us_adj_record<'a> (conn : &PgConnection, user_id : &i32, adjective_id : &i32, count_of_repeats : &i32) -> UserAdjective {
    let count = count_of_repeats + 1;
    diesel::update(user_adjective::table
        .filter(user_adjective::user_id.eq(user_id))
        .filter(user_adjective::adjective_id.eq(adjective_id)))
        .set(user_adjective::count.eq(count))
        .get_result(conn)
        .expect("Error updating data in the users_adjectives table!")
}
 
 
pub fn create_us_adj_record<'a>(conn : &PgConnection, user_id : &'a i32, adjective_id : &'a i32) -> UserAdjective {
    let new_usad_record = NewUsAdRecord {
        user_id,
        adjective_id,
        count : &1i32
    };
 
    diesel::insert_into(user_adjective::table)
        .values(&new_usad_record)
        .get_result(conn)
        .expect("Error saving new record in the users_adjectives table!")
}
 
 
pub fn get_top10_us_adj_for_user(connection : &PgConnection, user : &User) -> Result<Vec<UserAdjective>, Error> {
    let query = user_adjective::table
        .filter(user_adjective::user_id.eq(user.id))
        .order(user_adjective::adjective_id)
        .order(user_adjective::count.desc())
        .limit(10);
 
    let us_adj : Vec<UserAdjective> = query.load::<UserAdjective>(connection)?;
 
    Ok(us_adj)
}
 
pub fn get_top10_us_adj_for_adjective(connection : &PgConnection, adjective : &Adjective) -> Result<Vec<UserAdjective>, Error> {
    let query = user_adjective::table
        .filter(user_adjective::adjective_id.eq(adjective.id))
        .order(user_adjective::user_id)
        .order(user_adjective::count.desc())
        .limit(10);
 
    let us_adj : Vec<UserAdjective> = query.load::<UserAdjective>(connection)?;
 
    Ok(us_adj)
}

use database::schema::*;
use database::models::{ user::User
                        , adjective::Adjective
                        , user_adjective::{ UserAdjective
                                            , NewUsAdRecord }

Result<Vec<UserAdjective>, Error>

use rand::{ thread_rng, Rng };
 
#[derive(Debug)]
pub struct RandomData<T> {
    pub value : T,
}
 
impl <T : Clone> RandomData<T> {
 
    pub fn new(vector : &[T]) -> Self {
        let mut rng = thread_rng();
        let value = rng.choose(&vector).unwrap();
        RandomData { value : value.clone() }
    }
}

#[derive(Serialize)]
pub struct DisplayUser {
    pub user : User,
    pub adj_count : Vec<AdjCount>,
}
 
impl DisplayUser {
    pub fn by_id(connection : &DbConn, id : &i32) -> DisplayUser {
        let user = dbimpl::get_user_by_id(&connection, &id)
            .expect(&format!("User with id: {} no found!", id));
        DisplayUser::by_user(connection, user)
    }
 
    pub fn by_name(connection : &DbConn, name : &String) -> DisplayUser {
        let user = dbimpl::get_user_by_name(&connection, &name)
            .expect(&format!("User with name: {} no found!", name));
        DisplayUser::by_user(connection, user)
    }
 
    fn by_user(connection : &DbConn, user : User) -> DisplayUser {
        let top10 = dbimpl::get_top10_us_adj_for_user(connection, &user).
            expect(&format!("User not found in the database. User name is : {}", user.user_name));
        let mut adj_counts : Vec<AdjCount> = Vec::new();
        for top in top10 {
            let adjective = dbimpl::get_adjective_by_id(&connection, &top.adjective_id)
                .expect(&format!("Adjective not found in the database. adjective_id : {}", top.adjective_id));
            let count = dbimpl::get_count(&connection, &user, &adjective)
                .expect(&format!("Count not found for user_id: {}  and adjective_id: {}", user.id, adjective.id));
            let adj_count = AdjCount { adjective, count : count.first().unwrap().count.unwrap() };
            adj_counts.push(adj_count)
        }
        DisplayUser { user, adj_count : adj_counts }
    }
 
}

#[derive(Serialize)]
pub struct GenerateData {
    random_user_name : String,
    random_adjective_value : String,
}
 
 
impl GenerateData {
    pub fn new(connection : &DbConn, allDbData : &AllDbData) -> GenerateData {
        let random_adjective = RandomData::new(&allDbData.adjectives);
        let random_user = RandomData::new(&allDbData.users);
        create_or_update_us_adj(&connection, &random_user.value, &random_adjective.value);
        GenerateData {
            random_user_name : random_user.value.user_name,
            random_adjective_value : random_adjective.value.adjective_value,
        }
    }
}
 
impl<'r> Responder<'r> for GenerateData {
    fn respond_to(self, _: &Request) -> response::Result<'r> {
        Response::build()
            .sized_body(
                Cursor::new(
                    format!("<a href=\"/user/{user}\">{user}</a> cегодня <a href=\"/adjective/{adjective}\">{adjective}</a>",
                            user = self.random_user_name, adjective = self.random_adjective_value)))
            .ok()
    }
}

use rocket;
use database::connection;
use backend::handler;
use rocket_contrib::Template;
use middleware::display_data::AllDbData;
 
pub fn create_routes() {
    rocket::ignite()
        .manage(connection::init_pool())
        .manage(AllDbData::new())
        .mount("/",
               routes![ handler::index
                             , handler::all_users
                             , handler::all_adjectives
                             , handler::get_user_by_id
                             , handler::get_user_by_name
                             , handler::get_adjective_by_name
                             , handler::get_adjective_by_id
                             , handler::redirect
                             , handler::static_content
                             , handler::generate_new_one
                             ],
        )
        .attach(Template::fairing())
        .catch(catchers![handler::not_found])
        .launch();
}

#[get("/")]
fn index(connection : DbConn, allDbData : State<AllDbData>) -> Template {
    let context = IndexData::new(&connection, &allDbData);
    Template::render("index", &context)
}

#[get("/user/<id>")]
fn get_user_by_id(id: i32, connection: DbConn) -> Template {
    let context = DisplayUser::by_id(&connection, &id);
    Template::render("user", &context)
}
 
 
#[get("/user/<name>", rank = 2)]
fn get_user_by_name(name: String, connection: DbConn) -> Template {
    let context = DisplayUser::by_name(&connection, &name);
    Template::render("user", &context)
}

#[get("/static/<file..>")]
fn static_content(file: PathBuf) -> Result<NamedFile, StdIoError> {
     NamedFile::open(Path::new("static/").join(file))
}

#[get("/")]
fn index(connection : DbConn, allDbData : State<AllDbData>) -> Template {
    let context = IndexData::new(&connection, &allDbData);
    Template::render("index", &context)
}

#[derive(Serialize)]
pub struct IndexData {
    random_user_name : String,
    random_adjective_value : String,
    usadjcounts : Vec<UsAdjCount>,
}
 
impl IndexData {
    pub fn new(connection : &DbConn, allDbData : &AllDbData) -> IndexData {
        let most_frequent = dbimpl::get_top10_all(&connection)
            .unwrap_or(Vec::new());
        let mut usadjcounts = Vec::new();
        for most in most_frequent.iter() {
            let user = dbimpl::get_user_by_id(&connection, &most.user_id)
                .expect(&format!("User not found in the database. user_id : {}", most.user_id));
            let adjective = dbimpl::get_adjective_by_id(&connection, &most.adjective_id)
                .expect(&format!("Adjective not found in the database. adjective_id : {}", most.adjective_id));
            let count = most.count
                .expect(&format!("Cannot get count from database for user_id : {}", most.user_id));
            let usadjcount = UsAdjCount { user, adjective, count };
            usadjcounts.push(usadjcount);
        }
        let random_adjective = RandomData::new(&allDbData.adjectives);
        let random_user = RandomData::new(&allDbData.users);
        create_or_update_us_adj(&connection, &random_user.value, &random_adjective.value);
        IndexData {
            random_user_name : random_user.value.user_name,
            random_adjective_value : random_adjective.value.adjective_value,
            usadjcounts,
        }
    }
}

aList = [1, 2, 3, 4]

Result:
[1,2,3,4] : List number

[(1, 2, "three"), (4, 5, "six"), (7, 8, "nine")]

[(1, 2, "three"), (4, "five")]

-- TYPE MISMATCH --------------------------------------------- repl-temp-000.elm
 
The 1st and 2nd elements are different types of values.
 
3│   [(1, 2, "three"), (4, "five")]
                       ^^^^^^^^^^^
The 1st element has this type:
 
    ( number, number', String )
 
But the 2nd is:
 
    ( number, String )
 
Hint: All elements should be the same type of value so that we can iterate
through the list without running into unexpected values.

aList = [(1, 2, "three"),
         (4, 5, "six"),
         (7, 8, "nine")]

aList : List (number, number, String)
aList = [ (1, 2, "three")
        , (4, 5, "six")
        , (7, 8, "nine")
        ]

[1..10]

[1,2,3,4,5,6,7,8,9,10] : List number

> List.repeat 4 "Elm"
["Elm","Elm","Elm","Elm"] : List String

> 1 :: [2,3,4]
[1,2,3,4] : List number

> 1 :: 2 :: 3 :: 4 :: []
[1,2,3,4] : List number

> List.append [1, 2, 3] [4, 5]
[1,2,3,4,5] : List number

> [1, 2, 3] ++ [4, 5]
[1,2,3,4,5] : List number

> [1, 2, 3] ++ [4]
[1,2,3,4] : List number

> List.concat [ ["one", "two", "three"], ["four", "five"], ["six"], ["seven", "eight", "nine"] ]
["one","two","three","four","five","six","seven","eight","nine"] : List String

> List.map (\ word -> String.length word) ["a", "ab", "abc"]
[1,2,3] : List Int

> List.filter (\ n -> (n > 0)) [-1, 3, -2, 7]
[3,7] : List number

import Html
 
multiply : number -> number -> number
multiply a b = a * b
 
square : number -> number
square a = multiply a a
 
productOfSquares : number -> number -> number
productOfSquares a b = multiply (square a) (square b)
 
incrementAll : List number -> List number
incrementAll list = List.map (\ n -> n + 1) list
 
incrementAll2 : List number -> List number
incrementAll2 = List.map (\ n -> n + 1)
 
main : Html.Html
main =
  let
    print n = Html.text <| toString n
  in
    Html.p []
    [ print <| multiply 3 5
    , Html.br [] []
    , print <| square 4
    , Html.br [] []
    , print <| productOfSquares 2 3
    , Html.br [] []
    , print <| incrementAll [1, 2, 3]
    , Html.br [] []
    , print <| incrementAll2 [1, 2, 3]
    ]

import Html
 
multiply : number -> number -> number
multiply a b = a * b
 
multiplyByFive : number -> number
multiplyByFive = multiply 5
 
main : Html.Html
main = multiplyByFive 3 |> toString |> Html.text

incrementAll : List number -> List number
incrementAll list = List.map (\ n -> n + 1) list
 
incrementAll2 : List number -> List number
incrementAll2 = List.map (\ n -> n + 1)

multiply a b = a * b

square a = multiply a a

productOfSquares a b = multiply (square a) (square b)

incrementAll list = List.map (\ n -> n + 1) list

incrementAll2 = List.map (\ c -> c + 1)

import Html
 
multiply a b = a * b
 
square a = multiply a a
 
productOfSquares a b = multiply (square a) (square b)
 
incrementAll list = List.map (\ c -> c + 1) list
 
incrementAll2 = List.map (\ c -> c + 1)
 
main = Html.p []
  [ Html.text ("3 × 5   = " ++ (toString (multiply 3 5)))
  , Html.br [] []
  , Html.text ("4²      = " ++ (toString (square 4)))
  , Html.br [] []
  , Html.text ("2² × 3² = " ++ (toString (productOfSquares 2 3)))
  , Html.br [] []
  , Html.text ("incrementAll [1, 2, 3] = " ++ (toString (incrementAll [1, 2, 3])))
  , Html.br [] []
  , Html.text ("incrementAll2 [1, 2, 3] = " ++ (toString (incrementAll2 [1, 2, 3])))
  ]

main = Html.p []
  [ Html.text <| "3 × 5   = " ++ (toString <| multiply 3 5)
  , Html.br [] []
  , Html.text <| "4²      = " ++ (toString <| square 4)
  , Html.br [] []
  , Html.text <| "2² × 3² = " ++ (toString <| productOfSquares 2 3)
  , Html.br [] []
  , Html.text <| "incrementAll [1, 2, 3] = " ++ (toString <| incrementAll [1, 2, 3])
  , Html.br [] []
  , Html.text <| "incrementAll2 [1, 2, 3] = " ++ (toString <| incrementAll2 [1, 2, 3])
  ]

Html.text <| "3 × 5   = " ++ (toString <| multiply 3 5)

Html.text <| (++) "3 × 5   = " <| toString <| multiply 3 5

square 4 |> toString |> (++) "4²      = " |> Html.text

import Html
 
names = [ "Pearl", "Steven", "Garnet", "Amethyst" ]
 
main =
  let
    sorted = List.sort names
    texts = List.map Html.text sorted
    textToItem text = Html.li [] [ text ]
    items = List.map textToItem texts
  in
    Html.ul [] items

import Html
import Html.Attributes
 
names = [ "Pearl", "Steven", "Garnet", "Amethyst" ]
 
main =
  let
    sorted = List.sort names
    texts = List.map Html.text sorted
    textToItem text =
      Html.li
        [ Html.Attributes.style [("font-style", "italic") ] ]
        [ text ]
    items = List.map textToItem texts
  in
    Html.div
      [ Html.Attributes.style
        [ ("position", "absolute")
        , ("width", "10em")
        , ("height", "10em")
        , ("top", "50%")
        , ("left", "50%")
        , ("transform", "translateX(-50%) translateY(-50%)")
        , ("overflow", "hidden")
        ]
      ]
      [ Html.ul [] items ]

import Html
 
main = Html.text "Hello, World!"