oclock_sqlite 0.1.5

Time tracking utility (sqlite component)
Documentation 
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

use diesel;
use diesel::prelude::*;
use diesel::result::Error;
use diesel::sqlite::SqliteConnection;
use log::debug;

use crate::constants::SystemEventType;
use crate::models::{Event, NewEvent, Task};

type Backend = ::diesel::sqlite::Sqlite;

pub fn push_event(conn: &mut SqliteConnection, task: &NewEvent) -> Result<usize, Error> {
    use crate::schema::events;

    diesel::insert_into(events::table)
        .values(task)
        .execute(conn)
}

pub fn get_last_event(conn: &mut SqliteConnection) -> Result<Event, Error> {
    use crate::schema::events::dsl::*;

    events
    .order(event_timestamp.desc())
    .first(conn)
}

pub fn remove_all_system_events(conn: &mut SqliteConnection, event_name: String) {
    use crate::schema::events::dsl::*;

    let num_deleted = diesel::delete(events.filter(system_event_name.eq(&event_name)))
        .execute(conn)
        .expect(&format!("Error deleting system event {}", event_name));

    debug!("deleted {} system events with type {}", num_deleted, event_name);
}

pub fn move_system_event(conn: &mut SqliteConnection, unix_ts: i32, event_name: String) {
    use crate::schema::events::dsl::*;

    diesel::update(events.filter(system_event_name.eq(&event_name)))
        .set(event_timestamp.eq(unix_ts))
        .execute(conn)
        .expect(&format!("Error updating {} timestamp", event_name));
}

pub fn current_task(conn: &mut SqliteConnection) -> Result<Option<Task>, Error> {
    use crate::schema::events::dsl::*;
    use crate::schema::tasks::dsl::*;
    use crate::schema::tasks::dsl::id;

    let last_evt_query = events
    .filter(
        system_event_name.ne(SystemEventType::Ping.to_string())
        .or(system_event_name.is_null())
    )
    .order(event_timestamp.desc());

    debug!("Last event query: {}", diesel::debug_query::<Backend, _>(&last_evt_query));

    let last_evt =
    last_evt_query
    .first::<Event>(conn);

    debug!("Last event: {:?}", last_evt);

    match last_evt {
        Ok(Event{task_id: Some(curr_task_id), ..}) => {
            let task = tasks
            .filter(id.eq(curr_task_id))
            .first(conn)?;

            Ok(Some(task))
            },
        Ok(Event{task_id: None, ..}) => Ok(None),
        Err(e) => Err(e)
    }
}