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
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
|
use rand::{thread_rng, Rng};
use serenity::http::AttachmentType;
use serenity::builder::CreateMessage;
use serenity::framework::standard::Args;
use diesel::PgConnection;
use super::*;
use super::playback::CtxExt;
use db::*;
use failure::Error;
use Result;
pub fn meme(ctx: &mut Context, msg: &Message, mut args: Args) -> Result<()> {
if args.len() == 0 {
return rand_meme(ctx, msg);
}
let search = args.full();
let conn = connection()?;
let mem = match find_meme(&conn, search) {
Ok(x) => x,
Err(e) => {
send(msg.channel_id, "what in ryan's name", msg.tts)?;
return Err(e)
},
};
send_meme(ctx, &mem, &conn, msg)
}
pub fn addmeme(_: &mut Context, msg: &Message, mut args: Args) -> Result<()> {
let title = args.single_quoted::<String>()?;
let text = match args.multiple_quoted::<String>() {
Ok(text) => text.join(" "),
Err(_) => "".to_owned(),
};
let text = if text.is_empty() { None } else { Some(text) };
let conn = connection()?;
let image = msg.attachments.first()
.ok_or(::failure::err_msg("no attachment"))
.and_then(|att| {
let data = att.download()?;
Image::create(&conn, &att.filename, data, msg.author.id.0)
})
.ok();
if image.is_none() && text.is_none() {
return send(msg.channel_id, "hahAA it's empty xdddd", msg.tts);
}
NewMeme {
title,
content: text,
image_id: image,
audio_id: None,
metadata_id: 0,
}.save(&conn, msg.author.id.0).map(|_| {})?;
return msg.react("👌");
}
pub fn delmeme(_: &mut Context, msg: &Message, _: Args) -> Result<()> {
send(msg.channel_id, "hwaet", msg.tts)
}
pub fn renamememe(_: &mut Context, msg: &Message, _: Args) -> Result<()> {
send(msg.channel_id, "hwaet", msg.tts)
}
fn rand_meme(ctx: &Context, message: &Message) -> Result<()> {
let conn = connection()?;
let should_audio = ctx.currently_playing() && ctx.users_listening()?;
let modulus = if should_audio { 3 } else { 2 };
let mem = match thread_rng().gen::<u32>() % modulus {
0 => rand_text(&conn),
1 => rand_image(&conn),
2 => rand_audio(&conn),
_ => unreachable!(),
}
.or_else(|_| rand_text(&conn))
.and_then(|mut mem| {
let mut ctr = 0;
while !should_audio && mem.audio_id.is_some() {
mem = rand_text(&conn)?;
ctr += 1;
if ctr > 10 {
send(message.channel_id, "yer listenin to somethin else", message.tts)?;
bail!("looped too many times trying to find a non-audio meme");
}
}
Ok(mem)
});
match mem {
Err(e) => {
send(message.channel_id, "i don't know any :(", message.tts)?;
return Err(e);
},
_ => {},
}
send_meme(ctx, &mem?, &conn, message).map_err(Error::from)
}
fn send_meme(ctx: &Context, t: &Meme, conn: &PgConnection, msg: &Message) -> Result<()> {
debug!("sending meme: {:?}", t);
let image = t.image(conn);
let audio = t.audio(conn);
let create_msg = |m: CreateMessage| {
let ret = m
.tts(thread_rng().gen::<u32>() % 25 == 0);
match t.content {
Some(ref text) => ret.content(text),
None => ret
}
};
match image {
Some(image) => {
let image = image?;
msg.channel_id.send_files(vec!(AttachmentType::Bytes((&image.data, &image.filename))), create_msg)?
},
None => msg.channel_id.send_message(create_msg)?,
};
// note: slight edge-case race condition here: there could have been something queued since we
// checked whether anything was playing. not a significant negative impact and unlikely, so i'm
// not worrying about it
if let Some(audio) = audio {
let audio = audio?;
let queue_lock = ctx.data.lock().get::<PlayQueue>().cloned().unwrap();
let mut play_queue = queue_lock.write().unwrap();
play_queue.queue.push_front(PlayArgs{
initiator: msg.author.name.clone(),
data: ::either::Right(audio.data.clone()),
sender_channel: msg.channel_id,
});
}
Ok(())
}
|
