update_bot/src/main.rs

extern crate core;

use std::borrow::{Borrow, BorrowMut};
use std::collections::HashMap;
use std::fs::read_dir;
use std::path::{Path, PathBuf};
use std::thread;

use ::imp::event::Event;
use ::imp::imp;
use ::imp::imp::EventHandler;
use ::imp::imp::NewContactPolicy;
use libcwtch;
use libcwtch::CwtchLib;
use libcwtch::structs::*;
use serde_json;

use crate::imp::{Behaviour, BehaviourBuilder, Imp};

const DIST_DIR: &str = "cwtch_dist";
const BOT_HOME: &str = "~/.cwtch/bots/update_bot";
const PASSWORD: &str = "be gay do crime";

const BOT_NAME: &str = "Update Bot";

const LAST_OFFERED_KEY: &str = "profile.last_version_offered";

struct UpdateBot {
    versions_dirs: Vec<PathBuf>,
    latest_version: PathBuf,
    version: String,
}

impl UpdateBot {
    pub fn new() -> Self {
        let mut versions_dirs = vec![];
        for entry in
        read_dir(Path::new(DIST_DIR)).expect(&format!("could not open '{}' dir", DIST_DIR))
        {
            let entry = entry.unwrap();
            let path: PathBuf = entry.path();
            if path.is_dir() {
                println!("version: {}", path.to_str().unwrap());
                versions_dirs.push(path);
            }
        }
        if versions_dirs.len() == 0 {
            panic!("no cwtch versions detected in {}!", DIST_DIR)
        }
        versions_dirs.sort();
        println!("sorted vd: {:?}", versions_dirs);
        let latest_version = versions_dirs[versions_dirs.len() - 1].clone();
        let version: String = latest_version
            .strip_prefix(DIST_DIR)
            .unwrap()
            .to_str()
            .unwrap()
            .to_string();
        let mut bot = UpdateBot {
            versions_dirs: versions_dirs,
            latest_version: latest_version,
            version: version,
        };
        println!("versions: {:?}\n", bot.versions_dirs);
        return bot;
    }
}

fn main() {
    if !Path::new(DIST_DIR).exists() {
        panic!("no '{}' directory with versions to distribute", DIST_DIR)
    }

    let mut update_bot = UpdateBot::new();
    let behaviour: Behaviour = BehaviourBuilder::new().name(BOT_NAME.to_string()).profile_pic_path("build_bot.png".to_string()).new_contact_policy(imp::NewContactPolicy::Accept).build();

    let event_loop_handle = thread::spawn(move || {
        let mut bot = Imp::spawn(behaviour, PASSWORD.to_string(), BOT_HOME.to_string());

        bot.event_loop::<UpdateBot>(update_bot.borrow_mut());
    });

    event_loop_handle.join().expect("Error running event loop");
}


impl UpdateBot {
    pub fn greet(&self, cwtch: &dyn CwtchLib, profile_opt: Option<&Profile>, convo_id: i32) {
        if let Some(profile) = profile_opt {
            let do_offer = match cwtch.get_conversation_attribute(
                &profile.handle,
                convo_id,
                &format!("local.{}", LAST_OFFERED_KEY),
            ) {
                Ok(ret) => match ret {
                    Some(last_offered) => last_offered != self.version,
                    None => true,
                },
                Err(e) => false
            };
            if do_offer {
                self.offer(cwtch, profile_opt, convo_id);
                cwtch.set_conversation_attribute(
                    &profile.handle,
                    convo_id,
                    LAST_OFFERED_KEY,
                    &self.version,
                );
            }
        }
    }

    pub fn offer(&self, cwtch: &dyn CwtchLib, profile_opt: Option<&Profile>, convo_id: i32) {
        if let Some(profile) = profile_opt {
            let resp_message = format!(
                "Currently offering Cwtch {}\nPlease respond with the OS you would like a package for:\n- Windows\n- Android\n- MacOS\n- Linux",
                self.version
            );
            let response = Message {
                o: 1,
                d: resp_message,
            };
            match serde_json::to_string(&response) {
                Ok(response_json) => cwtch.send_message(&profile.handle, convo_id, &response_json),
                Err(e) => { println!("Error parsing json response: {}", e.to_string()); "".to_string() }
            };
        }
    }
}

impl imp::EventHandler for UpdateBot {
    fn handle(&mut self, cwtch: &dyn libcwtch::CwtchLib, profile_opt: Option<&Profile>, event: Event) {
        match event {
            Event::ContactCreated { data } => {
                let convo_id = data["ConversationID"].parse::<i32>().unwrap();
                self.greet(cwtch, profile_opt, convo_id);
            }
            Event::PeerStateChange { data } => {
                if data["ConnectionState"] == "Authenticated" {
                    match profile_opt.as_ref() {
                        Some(profile) => {
                            match profile.find_conversation_id_by_handle(data["RemotePeer"].clone()) {
                                Some(conversation_id) => self.greet(cwtch, profile_opt, conversation_id),
                                None => {}
                            }
                        }
                        None => (),
                    };
                }
            }
            Event::NewMessageFromPeer { conversation_id, handle, timestamp_received, message } => {
                match profile_opt {
                    Some(profile) => {
                        let from = profile.handle.as_str();
                        let message_wrapper: Message =
                            serde_json::from_str(&message).expect("Error parsing message");
                        let mut message = message_wrapper.d.clone();
                        message.make_ascii_lowercase();

                        match message.as_str() {
                            "windows" => {
                                let mut windows_path = self.latest_version.clone();
                                windows_path.push("cwtch-installer.exe");
                                cwtch.share_file(&from, conversation_id, windows_path.to_str().unwrap());
                            }
                            "linux" => {
                                let mut linux_path = self.latest_version.clone();
                                linux_path.push(format!("cwtch-{}.tar.gz", self.version));
                                cwtch.share_file(&from, conversation_id, linux_path.to_str().unwrap());
                            }
                            "macos" => {
                                let mut mac_path = self.latest_version.clone();
                                mac_path.push("Cwtch.dmg");
                                cwtch.share_file(&from, conversation_id, mac_path.to_str().unwrap());
                            }
                            "android" => {
                                let mut android_path = self.latest_version.clone();
                                android_path.push("app-release.apk");
                                cwtch.share_file(&from, conversation_id, android_path.to_str().unwrap());
                            }
                            _ => {
                                self.offer(cwtch, profile_opt, conversation_id);
                            }
                        }
                    }
                    _ => {}
                }
            }
            Event::ErrUnhandled { name, data } => eprintln!("unhandled event: {}!", name),
            _ => ()
        };
    }
}