instrumentality 0.3.0

A data aggregation platform.
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
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
121
122
123
124
125
126
127
128
129
130
131

//! Route for adding data to Instrumentality.
//!
//! The /add route is implemented here.
//!
//! See endpoint documentation at
//! <https://docs.berserksystems.com/endpoints/add/>.
//!
//! See [`Data`] for examples of valid data objects.

use axum::Extension;
use axum::{http::StatusCode, response::IntoResponse, Json};
use mongodb::bson::doc;
use mongodb::Collection;

use crate::config::IConfig;
use crate::data::{Data, Datas};
use crate::database::DBHandle;
use crate::routes::queue;
use crate::routes::queue::InternalQueueItem;
use crate::routes::response::{ErrorResponse, OkResponse};
use crate::user::User;

pub async fn add(
    user: User,
    mut db: DBHandle,
    Extension(config): Extension<IConfig>,
    Json(datas): Json<Datas>,
) -> impl IntoResponse {
    if datas.data.is_empty() {
        return error!(BAD_REQUEST, "No data was submitted.");
    }

    if let Some(queue_id) = datas.queue_id.as_ref() {
        if get_queue_item(queue_id, &user, &mut db).await.is_none() {
            return error!(BAD_REQUEST, "Invalid queue ID.");
        }
    }

    match process(datas, &config, &user, &mut db).await {
        true => ok!(CREATED),
        false => error!(
            BAD_REQUEST,
            "No valid data was submitted. Ensure the given platforms and 
                content/presence types are supported by this server. Ensure all 
                data was correctly labeled for queue jobs."
        ),
    }
}

async fn get_queue_item(
    queue_id: &str,
    user: &User,
    db: &mut DBHandle,
) -> Option<InternalQueueItem> {
    let q_coll: Collection<InternalQueueItem> = db.collection("queue");
    let queue_item = q_coll
        .find_one_with_session(
            doc! {"queue_id": &queue_id, "lock_holder": &user.uuid },
            None,
            &mut db.session,
        )
        .await
        .unwrap();

    queue_item
}

// The logic for this function needs to be simplified.
// This function resolves a number of uncertainties:
// - Is there any data remaining after verifying against the config?
// - If there is a valid queue ID, if there is a valid queue item for that queue
//   ID, is there any data remaining after verifying against the queue item?
// - Does the data succeed in verifying against the queue?
// And then it adds the data if all the answers are yes.
async fn process(
    datas: Datas,
    config: &IConfig,
    user: &User,
    db: &mut DBHandle,
) -> bool {
    let data_coll: Collection<Data> = db.collection("data");

    let datas = datas.tag(&user.uuid).verify_for_config(config);

    if datas.data.is_empty() {
        return false;
    }

    if let Some(queue_id) = &datas.queue_id.clone() {
        let queue_item = get_queue_item(queue_id, user, db).await;

        if queue_item.is_none() {
            return false;
        }

        let queue_item = queue_item.unwrap();
        let datas = datas.verify_for_queue(queue_item);

        if datas.data.is_empty() {
            return false;
        }

        let (platform_id, platform, added_by, username) = datas.info();

        let process_success = queue::process(
            queue_id,
            &platform_id,
            &platform,
            &added_by,
            username,
            db,
        )
        .await;

        if !process_success {
            false
        } else {
            data_coll
                .insert_many_with_session(datas.data, None, &mut db.session)
                .await
                .unwrap();
            db.session.commit_transaction().await.is_ok()
        }
    } else {
        data_coll
            .insert_many_with_session(datas.data, None, &mut db.session)
            .await
            .unwrap();
        db.session.commit_transaction().await.is_ok()
    }
}