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

// Copyright (c) 2019 Emmanuel Gil Peyrot <linkmauve@linkmauve.fr>
//
// This Source Code Form is subject to the terms of the Mozilla Public
// License, v. 2.0. If a copy of the MPL was not distributed with this
// file, You can obtain one at http://mozilla.org/MPL/2.0/.

use super::Agent;
use crate::Event;
use std::fs::{self, File};
use std::io::{self, Write};
use tokio_xmpp::connect::ServerConnector;
use tokio_xmpp::parsers::{
    avatar::{Data, Metadata},
    iq::Iq,
    jid::Jid,
    ns,
    pubsub::{
        event::Item,
        pubsub::{Items, PubSub},
        NodeName,
    },
};

pub(crate) async fn handle_metadata_pubsub_event<C: ServerConnector>(
    from: &Jid,
    agent: &mut Agent<C>,
    items: Vec<Item>,
) -> Vec<Event> {
    let mut events = Vec::new();
    for item in items {
        let payload = item.payload.clone().unwrap();
        if payload.is("metadata", ns::AVATAR_METADATA) {
            match Metadata::try_from(payload) {
                Ok(metadata) => {
                    for info in metadata.infos {
                        let filename = format!("data/{}/{}", from, &*info.id.to_hex());
                        let file_length = match fs::metadata(filename.clone()) {
                            Ok(metadata) => metadata.len(),
                            Err(_) => 0,
                        };
                        // TODO: Also check the hash.
                        if info.bytes as u64 == file_length {
                            events.push(Event::AvatarRetrieved(from.clone(), filename));
                        } else {
                            let iq = download_avatar(from);
                            let _ = agent.client.send_stanza(iq.into()).await;
                        }
                    }
                }

                Err(e) => error!("Error parsing avatar metadata: {}", e),
            }
        }
    }
    events
}

fn download_avatar(from: &Jid) -> Iq {
    Iq::from_get(
        "coucou",
        PubSub::Items(Items {
            max_items: None,
            node: NodeName(String::from(ns::AVATAR_DATA)),
            subid: None,
            items: Vec::new(),
        }),
    )
    .with_to(from.clone())
}

// The return value of this function will be simply pushed to a Vec in the caller function,
// so it makes no sense to allocate a Vec here - we're lazy instead
pub(crate) fn handle_data_pubsub_iq<'a>(
    from: &'a Jid,
    items: &'a Items,
) -> impl IntoIterator<Item = Event> + 'a {
    let from = from.clone();
    items
        .items
        .iter()
        .filter_map(move |item| match (&item.id, &item.payload) {
            (Some(id), Some(payload)) => {
                let data = Data::try_from(payload.clone()).unwrap();
                let filename = save_avatar(&from, id.0.clone(), &data.data).unwrap();
                Some(Event::AvatarRetrieved(from.clone(), filename))
            }
            _ => None,
        })
}

fn save_avatar(from: &Jid, id: String, data: &[u8]) -> io::Result<String> {
    let directory = format!("data/{}", from);
    let filename = format!("data/{}/{}", from, id);
    fs::create_dir_all(directory)?;
    let mut file = File::create(&filename)?;
    file.write_all(data)?;
    Ok(filename)
}