+# vote data

+**.vd

+name = "btparse"

+version = "0.1.1"

+checksum = "ca8fb3f04d0ef6cb7d39262d6c2bad0eec0c00071083ceddeb8bbcf693ff28a6"

+ "hermit-abi",

+ "btparse",

+ "serde",

+ "serde_json",

+version = "0.1.25"

+checksum = "8803eee176538f94ae9a14b55b2804eb7e1441f8210b1c31290b3bccdccff73b"

+ "time",

+serde = "1.0"

+serde_json = "1.0"

+btparse = "0.1.1"

+const ITEMS: &[&str] = &[

+ .captures(from)

+ .map(ToString::to_string)

+#[derive(Debug)]

+const PFX: &str = "-";

+ voting::fixall(),

+ voting::list(),

+ on_error: |e| Box::pin(on_error(e)),

+ // todo: voting::fixall() auto

+ f.run().await.unwrap();

+async fn on_error(error: poise::FrameworkError<'_, Data, anyhow::Error>) {

+ use poise::FrameworkError::Command;

+ match error {

+ Command { error, ctx } => {

+ ctx.say(format!("e: `{error}`")).await.unwrap();

+ if let Ok(n) = std::env::var("RUST_LIB_BACKTRACE") {

+ use std::str::FromStr;

+ if let Ok(n) = u8::from_str(&n) {

+ if n == 1 {

+ let mut parsed = btparse::deserialize(dbg!(error.backtrace())).unwrap();

+ let mut s = vec![];

+ for frame in &mut parsed.frames {

+ if let Some(line) = frame.line.take() {

+ if frame.function.contains("panel")

+ || frame.function.contains("poise")

+ || frame.function.contains("serenity")

+ {

+ s.push(format!("l{}@{}", line, frame.function));

+ }

+ }

+ }

+ s.truncate(15);

+ ctx.say(format!("trace: ```rs\n{}\n```", s.join("\n")))

+ .await

+ .unwrap();

+ }

+ }

+ }

+ }

+ err => poise::builtins::on_error(err).await.unwrap(),

+ }

+}

+

+ let line = $crate::bot::get_nextblock().await;

+ });

+use tokio::time::{sleep, Duration};

+ _ = sleep(Duration::from_secs(5)) => fail!(ctx, FAIL),

+ let Some((tps,mem,pcount)) = parse(&block) else {

+ fail!(ctx, FAIL);

+ .field("memory use", humanize_bytes(Size::Mb(f64::from(mem))), true)

+ assert!(humanize_bytes(Size::Mb(2000.0)) == "2 GB");

+use anyhow::anyhow;

+use serde::{Deserialize, Serialize};

+use std::fs::{read_dir, File};

+use std::io::BufReader;

+use std::path::Path;

+use tokio::time::*;

+

+#[derive(Default, Clone, Serialize, Deserialize, Debug)]

+struct VoteOptions {

+ options: Vec<String>,

+ styles: Vec<ButtonStyle>,

+ title: String,

+ fields: HashMap<String, String>,

+ image: Option<String>,

+}

+

+#[derive(Serialize, Deserialize, Debug, Clone, Default)]

+pub struct BeforePushVoteData {

+ votes: HashMap<UserId, Vote>,

+ // you can parse this from the message but its easier to do this

+ deadline: Duration,

+ #[serde(skip)]

+ deadline_changed: Duration,

+ options: VoteOptions,

+ #[serde(skip)]

+ reply: Option<Box<Message>>,

+ id: u64,

+ mid: MessageId,

+ cid: ChannelId,

+ endat: u64,

+}

+

+#[derive(Clone, Debug)]

+pub struct AfterPushVoteData {

+ index: usize,

+ deadline_changed: Duration,

+ options: VoteOptions,

+ id: u64,

+}

+

+macro_rules! read {

+ ($self:expr,$ctx:expr,$v:expr) => {{

+ $v = $ctx.data().vote_data.lock().unwrap();

+ match $v.get_mut($self.index).unwrap() {

+ VoteData::Before(x) => x,

+ VoteData::After(_) => unreachable!(),

+ }

+ }};

+}

+

+#[derive(Debug)]

+ Before(BeforePushVoteData),

+ After(AfterPushVoteData),

+}

+

+pub type Votes = Mutex<Vec<VoteData>>;

+

+trait EmbedUtil {

+ fn imageor<S: ToString>(&mut self, img: Option<S>) -> &mut Self;

+ fn set_fields<M: IntoIterator<Item = (S, S)>, S: ToString>(&mut self, fields: M) -> &mut Self;

+}

+

+impl EmbedUtil for CreateEmbed {

+ fn imageor<S: ToString>(&mut self, img: Option<S>) -> &mut Self {

+ if let Some(iuri) = img {

+ self.image(iuri)

+ } else {

+ self

+ }

+ }

+

+ fn set_fields<M: IntoIterator<Item = (S, S)>, S: ToString>(&mut self, fields: M) -> &mut Self {

+ for (k, v) in fields {

+ self.field(k, v, false);

+ }

+ self

+ }

+}

+

+macro_rules! votes {

+ ($self:expr, $ctx:expr, $v:expr) => {

+ match &mut $self {

+ VoteData::After(a) => &mut read!(a, $ctx, $v).votes,

+ VoteData::Before(b) => &mut b.votes,

+ }

+ };

+ pub fn summarize(&mut self, ctx: &Context<'_>, optcount: usize) -> Vec<usize> {

+ let mut ret = vec![];

+ ret.resize(optcount, 0);

+ let mut v;

+ for v in votes!(*self, ctx, v).values() {

+ ret[*v] += 1;

+ }

+ ret

+ }

+

+ fn deadline(&self) -> Duration {

+ Self::After(a) => a.deadline_changed,

+ Self::Before(b) => b.deadline_changed,

+ fn id(&self) -> u64 {

+ Self::After(a) => a.id,

+ Self::Before(b) => b.id,

+ }

+ }

+

+ fn options(&self) -> &VoteOptions {

+ match self {

+ Self::After(a) => &a.options,

+ Self::Before(b) => &b.options,

+ }

+ }

+

+ fn set_reply(&mut self, ctx: &Context<'_>, reply: Message) {

+ let mut v;

+ let mid = reply.id;

+ let cid = reply.channel_id;

+ let reply = Some(Box::new(reply));

+ match self {

+ Self::After(a) => {

+ let read = read!(a, ctx, v);

+ read.reply = reply;

+ read.mid = mid;

+ read.cid = cid;

+ }

+ Self::Before(b) => {

+ b.reply = reply;

+ b.mid = mid;

+ b.cid = cid;

+ fn get_reply(&mut self, ctx: &Context<'_>) -> Box<Message> {

+ let mut v;

+ Self::After(a) => read!(a, ctx, v).reply.take().unwrap(),

+ Self::Before(b) => b.reply.take().unwrap(),

+ fn set_end(&mut self) {

+ let end = self.dead_secs();

+ match self {

+ Self::Before(x) => x.endat = end,

+ _ => unreachable!(),

+ }

+ fn dead_secs(&self) -> u64 {

+ (SystemTime::now() + self.deadline())

+ .duration_since(SystemTime::UNIX_EPOCH)

+ .unwrap()

+ .as_secs()

+ }

+ fn end_stamp(&self) -> String {

+ format!("<t:{}:R>", self.dead_secs())

+ }

+

+ pub async fn begin(mut self, ctx: Context<'_>) -> Result<Self> {

+ self.set_end();

+ let o = self.options();

+ let handle = poise::send_reply(ctx, |m| {

+ m.embed(|e| {

+ e.imageor(o.image.as_ref())

+ .color(SUCCESS)

+ .title(&o.title)

+ .description(format!("vote ends {}", self.end_stamp()))

+ .set_fields(&o.fields)

+ })

+ .components(|c| {

+ c.create_action_row(|r| {

+ for (n, option) in o.options.iter().enumerate() {

+ r.create_button(|b| {

+ b.custom_id(format!("{}{n}", self.id()))

+ .label(option)

+ .style(o.styles[n])

+ });

+ }

+ r

+ })

+ })

+ })

+ .await?;

+ let msg = handle.into_message().await?;

+ self.set_reply(&ctx, msg);

+ self.push(&ctx).save(&ctx)

+ }

+

+ fn save_ref(&self, ctx: &Context<'_>) -> Result<()> {

+ let t = self.options().title.clone() + ".vd";

+ let mut re;

+ let thing = match &self {

+ Self::Before(x) => x,

+ Self::After(y) => {

+ re = ctx.data().vote_data.lock().unwrap();

+ match re.get_mut(y.index).unwrap() {

+ VoteData::Before(x) => x,

+ VoteData::After(_) => unreachable!(),

+ }

+ }

+ };

+ std::fs::write(t, serde_json::to_string(thing)?)?;

+ Ok(())

+ }

+

+ pub fn save(self, ctx: &Context<'_>) -> Result<Self> {

+ self.save_ref(ctx)?;

+ Ok(self)

+ }

+

+ pub fn push(self, ctx: &Context<'_>) -> Self {

+ let mut data = ctx.data().vote_data.lock().unwrap();

+ let n = data.len();

+ let v = Self::After(AfterPushVoteData {

+ index: n,

+ id: self.id(),

+ deadline_changed: self.deadline(),

+ options: self.options().clone(),

+ });

+ data.push(self);

+ v

+ }

+

+ fn remove(self, ctx: &Context<'_>) -> Self {

+ match self {

+ Self::After(x) => ctx.data().vote_data.lock().unwrap().remove(x.index),

+ Self::Before(_) => unreachable!(),

+ }

+ }

+

+ pub async fn input(mut self, ctx: &Context<'_>) -> Result<Self> {

+ let dead = self.deadline();

+ let ctx_id = self.id();

+ let ctx_id_len = ctx_id.to_string().len();

+ let o = self.options().clone();

+ let timestamp = self.end_stamp();

+ while let Some(press) = CollectComponentInteraction::new(ctx)

+ .filter(move |press| press.data.custom_id.starts_with(&ctx_id.to_string()))

+ .timeout(dead)

+ .await

+ {

+ let s = {

+ let mut v;

+ if votes!(self, ctx, v)

+ .insert(

+ press.user.id,

+ Vote::from_str(&press.data.custom_id[ctx_id_len..]).unwrap(),

+ )

+ .is_some()

+ {

+ "updated"

+ } else {

+ "voted"

+ }

+ };

+ self.save_ref(ctx)?;

+ let (_m, _) = tokio::join!(

+ press.create_followup_message(ctx, |m| { m.ephemeral(true).content(s) }),

+ press.create_interaction_response(ctx, |c| {

+ c.kind(InteractionResponseType::UpdateMessage)

+ .interaction_response_data(|m| {

+ m.embed(|e| {

+ for (option, votes) in

+ self.summarize(ctx, o.options.len()).iter().enumerate()

+ {

+ e.field(&o.options[option], votes, true);

+ }

+ e.imageor(o.image.as_ref())

+ .color(SUCCESS)

+ .title(&o.title)

+ .set_fields(&o.fields)

+ .description(format!("vote ends {timestamp}"))

+ })

+ })

+ })

+ );

+ // let m = m?;

+ // let http = ctx.serenity_context().http.clone();

+ // tokio::spawn(async move {

+ // sleep(Duration::from_secs(10)).await;

+ // m.delete(http).await.unwrap();

+ // });

+ }

+ Ok(self)

+ }

+

+ pub async fn finish(mut self, ctx: &Context<'_>) -> Result<()> {

+ let o = self.options().clone();

+ let filename = format!("{}.vd", o.title);

+ let p = std::path::Path::new(&filename);

+ if p.exists() {

+ let _ = std::fs::remove_file(p);

+ }

+ self.get_reply(ctx)

+ .edit(ctx, |m| {

+ m.embed(|e| {

+ for (option, votes) in self

+ .remove(ctx)

+ .summarize(ctx, o.options.len())

+ .iter()

+ .enumerate()

+ {

+ e.field(&o.options[option], votes, true);

+ }

+ e.color(DISABLED)

+ .title(&o.title)

+ .imageor(o.image.as_ref())

+ .set_fields(o.fields)

+ .description(format!("vote ended!"))

+ })

+ .components(|c| {

+ c.set_action_row({

+ let mut r = CreateActionRow::default();

+ for (n, option) in o.options.iter().enumerate() {

+ r.create_button(|b| {

+ b.label(option)

+ .disabled(true)

+ .style(o.styles[n])

+ .custom_id("_")

+ });

+ }

+ r

+ })

+ })

+ })

+ .await?;

+ Ok(())

+ }

+trait Parsing {

+ fn parse_pscsp(self) -> HashMap<String, String>;

+ fn parse_psv(self) -> Vec<String>;

+ fn parse_psv_to_styles(self) -> Vec<ButtonStyle>;

+}

+

+impl<S> Parsing for S

+where

+ S: AsRef<str>,

+{

+ fn parse_pscsp(self) -> HashMap<String, String> {

+ let pair = self.as_ref().split('|');

+ let pairs = pair.map(|s| {

+ s.split(':')

+ .map(|s| s.trim().to_owned())

+ .collect_tuple()

+ .unwrap()

+ });

+ let mut map = HashMap::new();

+ for (k, v) in pairs {

+ map.insert(k, v);

+ map

+ }

+ fn parse_psv(self) -> Vec<String> {

+ self.as_ref()

+ .split('|')

+ .map(|s| s.trim().to_owned())

+ .collect()

+ }

+ fn parse_psv_to_styles(self) -> Vec<ButtonStyle> {

+ self.as_ref()

+ .split('|')

+ .map(|s| {

+ use ButtonStyle::*;

+ match s.trim().to_lowercase().as_str() {

+ // "blue" => Primary,

+ "gray" => Secondary,

+ "green" => Success,

+ "red" => Danger,

+ _ => Primary,

+ }

+ })

+ .collect()

+ #[description = "option styles (psv) {blue|gray|green|red}"] styles: Option<String>,

+ #[description = "fields (pipe separated colon seperated pairs) (a:b|c:d)"] fields: Option<

+ String,

+ >,

+ let options = options.parse_psv();

+ let styles = styles.map_or(

+ vec![ButtonStyle::Primary; options.len()],

+ Parsing::parse_psv_to_styles,

+ );

+ let fields = fields.as_ref().map_or(HashMap::new(), Parsing::parse_pscsp);

+ let Ok(dur) = parse_duration::parse(&length) else {

+

+ VoteData::Before({

+ BeforePushVoteData {

+ votes: HashMap::new(),

+ deadline: dur,

+ deadline_changed: dur,

+ options: VoteOptions {

+ options,

+ styles,

+ title,

+ fields,

+ image,

+ },

+ reply: None,

+ id: ctx.id(),

+ ..Default::default()

+ }

+ })

+ .begin(ctx)

+ .await?

+ .input(&ctx)

+ .await?

+ .finish(&ctx)

+ .await

+}

+

+async fn fix(ctx: &Context<'_>, data: BufReader<std::fs::File>) -> Result<()> {

+ let mut v: BeforePushVoteData = serde_json::from_reader(data)?;

+ let m = ctx.http().get_message(v.cid.0, v.mid.0).await?;

+ let end = dbg!(m.timestamp.unix_timestamp()) as u64;

+ v.reply = Some(Box::new(m));

+ let now = SystemTime::now()

+ .duration_since(SystemTime::UNIX_EPOCH)

+ .unwrap()

+ .as_secs();

+ let end = end + dbg!(v.deadline.as_secs());

+ println!("@{now} | :{end}");

+ // cant use abs() because unsigned

+ v.deadline_changed = if now < end {

+ Duration::from_secs(end - now)

+ } else {

+ Duration::from_secs(now - end)

+ };

+ let v = VoteData::Before(v);

+ if end < now {

+ v.push(&ctx).finish(&ctx).await

+ } else {

+ v.push(&ctx).input(&ctx).await?.finish(&ctx).await

+}

+

+#[poise::command(

+ slash_command,

+ category = "Discord",

+ required_permissions = "ADMINISTRATOR"

+)]

+pub async fn fixall(ctx: Context<'_>) -> Result<()> {

+ use futures::future;

+ let mut futs = vec![];

+ for e in read_dir(".")? {

+ let e = e?;

+ let fname = e.file_name();

+ let p = Path::new(&fname);

+ if let Some(ext) = p.extension() {

+ if ext == "vd" {

+ futs.push(fix(&ctx, BufReader::new(File::open(p).unwrap())));

+ }

+ }

+ }

+ let msg = format!("fixed {}", futs.len());

+ poise::send_reply(ctx, |m| m.content(msg).ephemeral(true)).await?;

+ future::join_all(futs).await;

+ Ok(())

+}

+

+// #[poise::command(

+// context_menu_command = "fix vote",

+// slash_command,

+// category = "Discord",

+// rename = "fix_vote",

+// required_permissions = "ADMINISTRATOR"

+// )]

+// /// restart vote (use ctx menu)

+// pub async fn reinstate(

+// ctx: Context<'_>,

+// #[description = "previous vote, id or link"] m: Message,

+// ) -> Result<()> {

+// static RE: LazyLock<Regex> = LazyLock::new(|| Regex::new(r#"<t:([0-9]+):R>"#).unwrap());

+// let e = m.embeds.get(0).ok_or(anyhow!("no embed?"))?;

+// let end = u64::from_str(

+// RE.captures(

+// m.embeds

+// .get(0)

+// .ok_or(anyhow!("no embed?"))?

+// .description

+// .as_ref()

+// .ok_or(anyhow!("no desc?"))?,

+// )

+// .ok_or(anyhow!("no timestamp?"))?

+// .get(1)

+// .unwrap()

+// .as_str(),

+// )

+// .unwrap();

+// let now = SystemTime::now()

+// .duration_since(SystemTime::UNIX_EPOCH)

+// .unwrap()

+// .as_secs();

+// let f = BufReader::new(std::fs::File::open(

+// e.title.to_owned().ok_or(anyhow!("no title?"))? + ".vd",

+// )?);

+// poise::send_reply(ctx, |m| m.content("yes").ephemeral(true)).await?;

+// let mut v: BeforePushVoteData = serde_json::from_reader(f)?;

+// v.reply = Some(Box::new(m));

+// // cant use abs() because unsigned

+// v.deadline = if now < end {

+// Duration::from_secs(end - now)

+// } else {

+// Duration::from_secs(now - end)

+// };

+// let v = VoteData::Before(v);

+// if end < now {

+// v.push(&ctx).finish(&ctx).await

+// } else {

+// v.push(&ctx).input(&ctx).await?.finish(&ctx).await

+// }

+// }

+

+// voters

+

+#[poise::command(prefix_command, slash_command, category = "Discord", rename = "votes")]

+pub async fn list(ctx: Context<'_>, #[description = "the vote title"] vote: String) -> Result<()> {

+ let vd = {

+ let buf = ctx.data().vote_data.lock().unwrap();

+ match &buf[buf

+ .iter()

+ .position(|x| x.options().title == vote)

+ .ok_or(anyhow!("vote doesnt exist"))?]

+ {

+ VoteData::Before(x) => x.clone(),

+ VoteData::After(_) => unreachable!(),

+ }

+ poise::send_reply(ctx, |m| {

+ m.allowed_mentions(|x| x.empty_parse()).embed(|e| {

+ let mut votes: HashMap<usize, Vec<u64>> = HashMap::new();

+ for (user, vote) in vd.votes {

+ votes.entry(vote).or_default().push(user.0);

+ }

+ for (vote, voters) in votes {

+ let mut s = vec![];

+ s.reserve(voters.len());

+ for person in voters {

+ s.push(format!("<@{person}>"));

+ e.field(&vd.options.options[vote], s.join("\n"), false);

+ }

+ e.color(SUCCESS)

+ .title(format!("voter list for {vote}"))

+ .footer(|f| f.text("privacy is a illusion"))

+use tokio::sync::broadcast::{self, error::TryRecvError};

+use tokio::time::sleep;

+ sleep(Duration::from_millis(500)).await;

+ _ = sleep(Duration::from_millis(500)) => continue,

+ sleep(Duration::from_millis(500)).await;

+use std::{net::SocketAddr, sync::Arc};

+use tokio::{sync::broadcast, task::JoinHandle, time::sleep, time::Duration};

+ Self { stdout, stdin }

+ .unwrap();

+ $backoff <<= 1;

+ sleep(Duration::from_secs($backoff)).await;

+ let Ok(spawn) = Process::spawn().await else {

+use tokio::time::{sleep, Duration, Instant};

+ sleep(Duration::from_millis(20)).await;

+ sleep(Duration::from_millis(20)).await;

+ for line in feed {

+ let message = message.take().unwrap();

+ self.send_message(n, &message).await;

+ current.take();

+ unnamed.madd(unify(&line));

+ if let Some((u, c)) = line.split(": ").map(unify).collect_tuple() {

+pub fn unify(s: &str) -> String {

+ s.chars().filter(|&c| c < 'џ').collect()