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

#![allow(clippy::needless_return)]
#![deny(clippy::implicit_return)]

use yttrium_key_base as key_base;
use key_base::environment::events;
use serenity::model::id::{UserId, RoleId};
use futures::executor;
#[cfg(feature = "loader")]
#[no_mangle]
pub fn key_create() -> *mut dyn key_base::Key {
	return Box::into_raw(Box::new(std_take {
		info: create_key_info(),
		function: key_function,
	}));
}

pub fn safe_create() -> Box<dyn key_base::Key> {
	return Box::new(std_take {
		info: create_key_info(),
		function: key_function,
	});
}

fn create_key_info() -> key_base::KeyInfo {
	return key_base::KeyInfo {
		name: String::from("take"),
		parameters_required: vec![1, 2],
	};
}

#[allow(non_camel_case_types)]
struct std_take {
	pub info: key_base::KeyInfo,
	pub function: fn(parameter: &[String], environment: &mut key_base::environment::Environment) -> Result<String, String>,
}

impl key_base::Key for std_take {
	fn get_key_info(&self) -> &key_base::KeyInfo {
		return &self.info;
	}

	fn get_key_function(&self) -> fn(parameter: &[String], environment: &mut key_base::environment::Environment) -> Result<String, String> {
		return self.function;
	}
}
fn key_function(parameter: &[String], environment: &mut key_base::environment::Environment) -> Result<String, String> {
	let matcher = regex::Regex::new(key_base::regexes::DISCORD_ID).unwrap();
	let guild_id = environment.guild_id.clone();
	let user_id;
	if parameter.len() == 1 {
		match &environment.event_info {
			events::EventType::Message(event) => {
				user_id = event.user_id.clone();
			}
			events::EventType::MemberJoin(event) => {
				user_id = event.user_id.clone();
			}
			events::EventType::MemberUpdate(event) => {
				user_id = event.user_id.clone();
			}
			events::EventType::VoiceUpdate(event) => {
				user_id = event.user_id.clone();
			}
			events::EventType::ReactionAdd(event) => {
				user_id = event.user_id.clone();
			}
			events::EventType::ReactionRemove(event) => {
				user_id = event.user_id.clone();
			}
			_ => {
				return Err(String::from("`take` was called on an invalid event without an ID"));
			}
		}
	} else {
		if matcher.is_match(&parameter[1]) {
			user_id = UserId::from(parameter[1].parse::<u64>().unwrap());
		} else {
			return Err(String::from("Invalid user ID passed to `take"));
		}
	}
	match executor::block_on(environment.discord_context.cache.guild(guild_id)) {
		Some(guild) => {
			let mut role_id;
			if matcher.is_match(&parameter[0]) {
				role_id = RoleId::from(parameter[0].parse::<u64>().unwrap());
				if !guild.roles.contains_key(&role_id) {
					//Safeguard against 18 characters long role names composed only of digits
					match guild.role_by_name(&parameter[0]) {
						Some(role) => {
							role_id = role.id;
						}
						None => {
							return Err(String::from("Could not find the role in `take`"));
						}
					}
				}
			} else {
				match guild.role_by_name(&parameter[0]) {
					Some(role) => {
						role_id = role.id;
					}
					None => {
						return Err(String::from("Could not find the role in `take`"));
					}
				}
			}
			match executor::block_on(guild.member(&environment.discord_context.http, user_id)) {
				Ok(mut member) => {
					if let Err(error) = executor::block_on(member.remove_role(&environment.discord_context.http, role_id)) {
						return Err(format!("Could not take the role in `take`: `{}`", error));
					}
				}
				Err(error) => {
					return Err(format!("Could not get the member in `take`: `{}`", error));
				}
			}
			return Ok(String::new());
		}
		None => {
			return Err(String::from("Could not find guild"));
		}
	}
}