Cleaned up postgre helpers (#4)

* Change status if not main

* Moved postgre functions

build.rs

@@ -1,10 +1,18 @@
 use std::process::Command;
 
 fn main() {
-  let output = Command::new("git")
+  let commit = Command::new("git")
     .args(&["rev-parse", "HEAD"])
     .output()
     .unwrap();
-  let git_hash = String::from_utf8(output.stdout).unwrap();
+  let branch = Command::new("git")
+    .args(&["rev-parse", "--abbrev-ref", "HEAD"])
+    .output()
+    .unwrap();
+
+  let git_hash = String::from_utf8(commit.stdout).unwrap();
+  let git_branch = String::from_utf8(branch.stdout).unwrap();
+
   println!("cargo:rustc-env=GIT_HASH={}", git_hash);
+  println!("cargo:rustc-env=GIT_BRANCH={}", git_branch);
 }

src/handler.rs

@@ -1,4 +1,4 @@
-use crate::postgres::store;
+use crate::postgres::{delete, get, store};
 use crate::twitch::automod;
 use crate::utils::mention;
 use serenity::{
@@ -29,12 +29,15 @@ impl EventHandler for Handler {
         shard[1],
       );
     }
+
+    let mut status = format!("Version: {}", &env!("GIT_HASH")[0..7]);
+    if &env!("GIT_BRANCH") != &"main" {
+      status = format!("Branch: {}", env!("GIT_BRANCH"));
+    }
+
     ctx
       .set_presence(
-        Some(Activity::listening(&format!(
-          "Version: {}",
-          &env!("GIT_HASH")[0..7]
-        ))),
+        Some(Activity::listening(&status)),
         OnlineStatus::DoNotDisturb,
       )
       .await;
@@ -73,7 +76,7 @@ impl EventHandler for Handler {
     }
   }
   async fn guild_create(&self, ctx: Context, guild: Guild, is_new: bool) {
-    if !is_new && !store::is_new_guild(ctx.clone(), guild.id.clone()).await {
+    if !is_new && !get::is_new_guild(ctx.clone(), guild.id.clone()).await {
       return;
     }
 
@@ -106,7 +109,7 @@ impl EventHandler for Handler {
     role_id: RoleId,
     _: Option<Role>,
   ) {
-    store::del_role(ctx, guild_id, role_id).await;
+    delete::role(ctx, guild_id, role_id).await;
   }
   async fn guild_role_update(&self, ctx: Context, guild_id: GuildId, _: Option<Role>, new: Role) {
     store::role(ctx, guild_id, &new).await;
@@ -127,6 +130,6 @@ impl EventHandler for Handler {
     user: User,
     _: Option<Member>,
   ) {
-    store::del_member(ctx, guild_id, user.id).await;
+    delete::member(ctx, guild_id, user.id).await;
   }
 }

src/postgres/delete.rs

@@ -0,0 +1,56 @@
+use crate::PostgresPool;
+use serenity::{
+  client::Context,
+  model::id::{GuildId, RoleId, UserId},
+};
+use std::convert::TryFrom;
+
+pub async fn role(ctx: Context, guild_id: GuildId, role_id: RoleId) {
+  let data = ctx.data.read().await;
+  let pool = match data.get::<PostgresPool>() {
+    Some(v) => v.get().await.unwrap(),
+    None => {
+      log::error!("Error getting the postgres pool.");
+      return;
+    }
+  };
+
+  match pool
+    .query(
+      "DELETE FROM roles WHERE id = $1 AND guild_id = $2",
+      &[
+        &i64::try_from(*role_id.as_u64()).unwrap(),
+        &i64::try_from(*guild_id.as_u64()).unwrap(),
+      ],
+    )
+    .await
+  {
+    Ok(_) => log::debug!("Deleted role {} in {}", role_id, guild_id),
+    Err(e) => log::error!("{:#?}", e),
+  };
+}
+
+pub async fn member(ctx: Context, guild_id: GuildId, user_id: UserId) {
+  let data = ctx.data.read().await;
+  let pool = match data.get::<PostgresPool>() {
+    Some(v) => v.get().await.unwrap(),
+    None => {
+      log::error!("Error getting the postgres pool.");
+      return;
+    }
+  };
+
+  match pool
+    .query(
+      "DELETE FROM members WHERE id = $1 AND guild_id = $2",
+      &[
+        &i64::try_from(*user_id.as_u64()).unwrap(),
+        &i64::try_from(*guild_id.as_u64()).unwrap(),
+      ],
+    )
+    .await
+  {
+    Ok(_) => log::debug!("Deleted member {} in {}", user_id, guild_id),
+    Err(e) => log::error!("{:#?}", e),
+  };
+}

src/postgres/get.rs

@@ -0,0 +1,24 @@
+use crate::PostgresPool;
+use serenity::{client::Context, model::id::GuildId};
+use std::convert::TryFrom;
+
+pub async fn is_new_guild(ctx: Context, guild_id: GuildId) -> bool {
+  let data = ctx.data.read().await;
+  let pool = match data.get::<PostgresPool>() {
+    Some(v) => v.get().await.unwrap(),
+    None => {
+      log::error!("Error getting the postgres pool.");
+      return false;
+    }
+  };
+
+  let has_guild = pool
+    .query(
+      "SELECT 1 FROM guilds WHERE id = $1",
+      &[&i64::try_from(*guild_id.as_u64()).unwrap()],
+    )
+    .await
+    .ok();
+
+  has_guild.unwrap().get(0).is_none()
+}

src/postgres/mod.rs

@@ -1,2 +1,4 @@
 pub mod connection;
+pub mod delete;
+pub mod get;
 pub mod store;

src/postgres/store.rs

@@ -5,82 +5,11 @@ use serenity::{
   model::{
     channel::Message,
     guild::{Guild, Member, PartialGuild, Role},
-    id::{GuildId, RoleId, UserId},
+    id::GuildId,
   },
 };
 use std::convert::TryFrom;
 
-pub async fn is_new_guild(ctx: Context, guild_id: GuildId) -> bool {
-  let data = ctx.data.read().await;
-  let pool = match data.get::<PostgresPool>() {
-    Some(v) => v.get().await.unwrap(),
-    None => {
-      log::error!("Error getting the postgres pool.");
-      return false;
-    }
-  };
-
-  let has_guild = pool
-    .query(
-      "SELECT 1 FROM guilds WHERE id = $1",
-      &[&i64::try_from(*guild_id.as_u64()).unwrap()],
-    )
-    .await
-    .ok();
-
-  has_guild.unwrap().get(0).is_none()
-}
-
-pub async fn del_role(ctx: Context, guild_id: GuildId, role_id: RoleId) {
-  let data = ctx.data.read().await;
-  let pool = match data.get::<PostgresPool>() {
-    Some(v) => v.get().await.unwrap(),
-    None => {
-      log::error!("Error getting the postgres pool.");
-      return;
-    }
-  };
-
-  match pool
-    .query(
-      "DELETE FROM roles WHERE id = $1 AND guild_id = $2",
-      &[
-        &i64::try_from(*role_id.as_u64()).unwrap(),
-        &i64::try_from(*guild_id.as_u64()).unwrap(),
-      ],
-    )
-    .await
-  {
-    Ok(_) => log::debug!("Deleted role {} in {}", role_id, guild_id),
-    Err(e) => log::error!("{:#?}", e),
-  };
-}
-
-pub async fn del_member(ctx: Context, guild_id: GuildId, user_id: UserId) {
-  let data = ctx.data.read().await;
-  let pool = match data.get::<PostgresPool>() {
-    Some(v) => v.get().await.unwrap(),
-    None => {
-      log::error!("Error getting the postgres pool.");
-      return;
-    }
-  };
-
-  match pool
-    .query(
-      "DELETE FROM members WHERE id = $1 AND guild_id = $2",
-      &[
-        &i64::try_from(*user_id.as_u64()).unwrap(),
-        &i64::try_from(*guild_id.as_u64()).unwrap(),
-      ],
-    )
-    .await
-  {
-    Ok(_) => log::debug!("Deleted member {} in {}", user_id, guild_id),
-    Err(e) => log::error!("{:#?}", e),
-  };
-}
-
 pub async fn message(ctx: Context, msg: Message, permitted: bool) {
   let data = ctx.data.read().await;
   let pool = match data.get::<PostgresPool>() {