Skynet/discord-bot
6
0
Fork 2
Code Issues 4 Pull requests Projects 1 Releases Packages Wiki Activity Actions

feat: modified the flake to use the new api #12

Merged
silver merged 3 commits from #5_wolves-api into main 2023-10-27 01:51:02 +00:00
Conversation 3 Commits 3 Files changed 5 +69 -160
5 changed files with 69 additions and 160 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

22
Cargo.lock generated
View file

@ -540,27 +540,6 @@ dependencies = [
"subtle",
]
[[package]]
name = "csv"
version = "1.2.2"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "626ae34994d3d8d668f4269922248239db4ae42d538b14c398b74a52208e8086"
dependencies = [
"csv-core",
"itoa",
"ryu",
"serde",
]
[[package]]
name = "csv-core"
version = "0.1.10"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "2b2466559f260f48ad25fe6317b3c8dac77b5bdb5763ac7d9d6103530663bc90"
dependencies = [
"memchr",
]
[[package]]
name = "ctr"
version = "0.6.0"
@ -2418,7 +2397,6 @@ name = "skynet_discord_bot"
version = "0.1.0"
dependencies = [
"chrono",
"csv",
"dotenvy",
"lettre",
"maud",

3
Cargo.toml
View file

@ -29,9 +29,6 @@ rand = "0.8.5"
# fancy time stuff
chrono = "0.4.26"
# handlign teh csv export from wolves
csv = "1.2"
# for email
lettre = "0.10.4"
maud = "0.25.0"

8
flake.nix
View file

@ -50,7 +50,6 @@
SKYNET_SERVER = cfg.discord.server;
HOME = cfg.home;
DATABASE = "database.db";
CSV = "wolves.csv";
};
service_name = script: lib.strings.sanitizeDerivationName("${cfg.user}@${script}");
@ -71,6 +70,7 @@
"${cfg.env.ldap}"
"${cfg.env.discord}"
"${cfg.env.mail}"
"${cfg.env.wolves}"
];
};
});
@ -113,6 +113,10 @@
type = types.str;
description = "ENV file with EMAIL_SMTP, EMAIL_USER, EMAIL_PASS";
};
wolves = mkOption rec {
type = types.str;
description = "Mail details, has WOLVES_URL, WOLVES_KEY";
};
};
discord = {
@ -178,12 +182,14 @@
"${cfg.env.ldap}"
"${cfg.env.discord}"
"${cfg.env.mail}"
"${cfg.env.wolves}"
];
};
restartTriggers = [
"${cfg.env.ldap}"
"${cfg.env.discord}"
"${cfg.env.mail}"
"${cfg.env.wolves}"
];
};
} // serviceGenerator scripts;

174
src/bin/update_data.rs
View file

@ -1,6 +1,6 @@
use skynet_discord_bot::{db_init, get_config, get_server_config_bulk, Config, ServerMembers, Servers, Wolves};
use serde::Deserialize;
use serde::{Deserialize, Serialize};
use serenity::model::id::GuildId;
use sqlx::{Pool, Sqlite};
@ -13,149 +13,75 @@ async fn main() {
};
// handle wolves api here
get_wolves_csv(&db, &config).await;
// handle wolves api here
get_wolves(&db).await;
get_wolves(&db, &config).await;
}
async fn get_wolves_csv(db: &Pool<Sqlite>, config: &Config) {
if let Ok(accounts) = get_csv(config) {
for account in accounts {
add_users_wolves_csv(db, &config.skynet_server, &account).await;
}
}
}
#[derive(Debug, serde::Deserialize)]
struct RecordCSV {
#[serde(rename = "MemID")]
mem_id: String,
#[serde(rename = "Contact Email")]
#[derive(Deserialize, Serialize, Debug)]
struct WolvesResultUser {
committee: String,
wolves_id: String,
first_name: String,
last_name: String,
email: String,
#[serde(rename = "Expiry")]
student_id: Option<String>,
note: Option<String>,
expiry: String,
requested: String,
approved: String,
sitename: String,
domain: String,
}
impl From<&RecordCSV> for Wolves {
fn from(input: &RecordCSV) -> Self {
Self {
id_wolves: input.mem_id.to_owned(),
email: input.email.to_owned(),
discord: None,
minecraft: None,
}
}
}
impl From<&RecordCSV> for ServerMembers {
fn from(input: &RecordCSV) -> Self {
Self {
server: Default::default(),
id_wolves: input.mem_id.to_owned(),
expiry: input.expiry.to_owned(),
}
}
}
struct Csv {
wolves: Wolves,
server_members: ServerMembers,
}
fn get_csv(config: &Config) -> Result<Vec<Csv>, Box<dyn std::error::Error>> {
let mut result = vec![];
let csv = format!("{}/{}", &config.home, &config.csv);
if let Ok(mut rdr) = csv::Reader::from_path(csv) {
for r in rdr.deserialize() {
// Notice that we need to provide a type hint for automatic
// deserialization.
let record: RecordCSV = r?;
if record.mem_id.is_empty() {
continue;
}
let mut tmp = ServerMembers::from(&record);
tmp.server = config.skynet_server;
result.push(Csv {
wolves: Wolves::from(&record),
server_members: tmp,
});
}
}
Ok(result)
}
async fn add_users_wolves_csv(db: &Pool<Sqlite>, server: &GuildId, user: &Csv) {
match sqlx::query_as::<_, Wolves>(
"
INSERT INTO wolves (id_wolves, email)
VALUES ($1, $2)
ON CONFLICT(id_wolves) DO UPDATE SET email = $2
",
)
.bind(&user.wolves.id_wolves)
.bind(&user.wolves.email)
.fetch_optional(db)
.await
{
Ok(_) => {}
Err(e) => {
println!("Failure to insert into {} {:?}", server.as_u64(), user.wolves);
println!("{:?}", e);
}
}
match sqlx::query_as::<_, ServerMembers>(
"
INSERT OR REPLACE INTO server_members (server, id_wolves, expiry)
VALUES (?1, ?2, ?3)
",
)
.bind(*server.as_u64() as i64)
.bind(&user.server_members.id_wolves)
.bind(&user.server_members.expiry)
.fetch_optional(db)
.await
{
Ok(_) => {}
Err(e) => {
println!("Failure to insert into {} {:?}", server.as_u64(), user.server_members);
println!("{:?}", e);
}
}
}
#[derive(Debug, Deserialize)]
pub struct SkynetResult {
discord: String,
id_member: String,
}
#[derive(Debug, Deserialize)]
#[derive(Deserialize, Serialize, Debug)]
struct WolvesResult {
success: i8,
result: Vec<WolvesResultUser>,
}
#[derive(Deserialize, Serialize, Debug)]
struct WolvesResultLocal {
pub id_wolves: String,
pub email: String,
pub expiry: String,
}
async fn get_wolves(db: &Pool<Sqlite>) {
async fn get_wolves(db: &Pool<Sqlite>, config: &Config) {
for server_config in get_server_config_bulk(db).await {
let Servers {
server,
//wolves_api,
wolves_api,
..
} = server_config;
// get the data here
let result: Vec<WolvesResult> = vec![];
for user in result {
for user in get_wolves_sub(config, &wolves_api).await {
add_users_wolves(db, &server, &user).await;
}
}
}
async fn add_users_wolves(db: &Pool<Sqlite>, server: &GuildId, user: &WolvesResult) {
async fn get_wolves_sub(config: &Config, wolves_api: &str) -> Vec<WolvesResultUser> {
if config.wolves_url.is_empty() {
return vec![];
}
// get wolves data
if let Ok(mut res) = surf::post(&config.wolves_url).header("X-AM-Identity", wolves_api).await {
if let Ok(WolvesResult {
success,
result,
}) = res.body_json().await
{
if success != 1 {
return vec![];
}
return result;
}
}
vec![]
}
async fn add_users_wolves(db: &Pool<Sqlite>, server: &GuildId, user: &WolvesResultUser) {
// expiry
match sqlx::query_as::<_, Wolves>(
"
@ -164,7 +90,7 @@ async fn add_users_wolves(db: &Pool<Sqlite>, server: &GuildId, user: &WolvesResu
ON CONFLICT(id_wolves) DO UPDATE SET email = $2
",
)
.bind(&user.id_wolves)
.bind(&user.wolves_id)
.bind(&user.email)
.fetch_optional(db)
.await
@ -183,7 +109,7 @@ async fn add_users_wolves(db: &Pool<Sqlite>, server: &GuildId, user: &WolvesResu
",
)
.bind(*server.as_u64() as i64)
.bind(&user.id_wolves)
.bind(&user.wolves_id)
.bind(&user.expiry)
.fetch_optional(db)
.await

22
src/lib.rs
View file

@ -23,7 +23,6 @@ pub struct Config {
pub ldap_api: String,
pub home: String,
pub database: String,
pub csv: String,
pub auth: String,
pub discord_token: String,
@ -31,6 +30,8 @@ pub struct Config {
pub mail_smtp: String,
pub mail_user: String,
pub mail_pass: String,
pub wolves_url: String,
}
impl TypeMapKey for Config {
type Value = Arc<RwLock<Config>>;
@ -53,11 +54,11 @@ pub fn get_config() -> Config {
home: ".".to_string(),
database: "database.db".to_string(),
csv: "wolves.csv".to_string(),
mail_smtp: "".to_string(),
mail_user: "".to_string(),
mail_pass: "".to_string(),
wolves_url: "".to_string(),
};
if let Ok(x) = env::var("LDAP_API") {
@ -72,9 +73,6 @@ pub fn get_config() -> Config {
if let Ok(x) = env::var("DATABASE") {
config.database = x.trim().to_string();
}
if let Ok(x) = env::var("CSV") {
config.csv = x.trim().to_string();
}
if let Ok(x) = env::var("LDAP_DISCORD_AUTH") {
config.auth = x.trim().to_string();
@ -94,6 +92,10 @@ pub fn get_config() -> Config {
config.mail_pass = x.trim().to_string();
}
if let Ok(x) = env::var("WOLVES_URL") {
config.wolves_url = x.trim().to_string();
}
config
}
@ -104,7 +106,7 @@ fn str_to_num<T: FromStr + Default>(x: &str) -> T {
#[derive(Debug, Clone, Deserialize, Serialize)]
pub struct ServerMembers {
pub server: GuildId,
pub id_wolves: String,
pub id_wolves: i64,
pub expiry: String,
}
impl<'r> FromRow<'r, SqliteRow> for ServerMembers {
@ -123,7 +125,7 @@ impl<'r> FromRow<'r, SqliteRow> for ServerMembers {
#[derive(Debug, Clone, Deserialize, Serialize)]
pub struct ServerMembersWolves {
pub server: GuildId,
pub id_wolves: String,
pub id_wolves: i64,
pub expiry: String,
pub email: String,
pub discord: Option<UserId>,
@ -158,7 +160,7 @@ impl<'r> FromRow<'r, SqliteRow> for ServerMembersWolves {
#[derive(Debug, Clone, Deserialize, Serialize)]
pub struct Wolves {
pub id_wolves: String,
pub id_wolves: i64,
pub email: String,
pub discord: Option<UserId>,
pub minecraft: Option<String>,
@ -268,7 +270,7 @@ pub async fn db_init(config: &Config) -> Result<Pool<Sqlite>, Error> {
sqlx::query(
"CREATE TABLE IF NOT EXISTS wolves (
id_wolves text PRIMARY KEY,
id_wolves integer PRIMARY KEY,
email text not null,
discord integer,
minecraft text
@ -297,7 +299,7 @@ pub async fn db_init(config: &Config) -> Result<Pool<Sqlite>, Error> {
sqlx::query(
"CREATE TABLE IF NOT EXISTS server_members (
server integer not null,
id_wolves text not null,
id_wolves integer not null,
expiry text not null,
PRIMARY KEY(server,id_wolves),
FOREIGN KEY (id_wolves) REFERENCES wolves (id_wolves)