feat: now using seperate tables for key info, joined when needed

This commit is contained in:
silver 2023-09-17 00:14:50 +01:00
parent f405cbbb93
commit 591c61b009
6 changed files with 225 additions and 198 deletions

View file

@ -1,4 +1,4 @@
use skynet_discord_bot::{db_init, get_config, get_server_config_bulk, Accounts, Config, Servers};
use skynet_discord_bot::{db_init, get_config, get_server_config_bulk, Config, ServerMembers, Servers, Wolves};
use serde::Deserialize;
use serenity::model::id::GuildId;
@ -38,66 +38,116 @@ struct RecordCSV {
expiry: String,
}
impl From<RecordCSV> for Accounts {
fn from(input: RecordCSV) -> Self {
impl From<&RecordCSV> for Wolves {
fn from(input: &RecordCSV) -> Self {
Self {
server: Default::default(),
id_wolves: "".to_string(),
id_member: input.mem_id,
email: input.email,
expiry: input.expiry,
id_wolves: input.mem_id.to_owned(),
email: input.email.to_owned(),
discord: None,
minecraft: None,
}
}
}
fn get_csv(config: &Config) -> Result<Vec<Accounts>, Box<dyn std::error::Error>> {
let mut records: Vec<Accounts> = vec![];
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 result in rdr.deserialize() {
for r in rdr.deserialize() {
// Notice that we need to provide a type hint for automatic
// deserialization.
let record: RecordCSV = result?;
let record: RecordCSV = r?;
if record.mem_id.is_empty() {
continue;
}
records.push(Accounts::from(record));
result.push(Csv {
wolves: Wolves::from(&record),
server_members: ServerMembers::from(&record),
});
}
}
Ok(records)
Ok(result)
}
async fn add_users_wolves_csv(db: &Pool<Sqlite>, server: &GuildId, user: &Accounts) {
let existing = match sqlx::query_as::<_, Accounts>(
r#"
SELECT *
FROM accounts
WHERE server = ? AND id_member = ?
"#,
async fn add_users_wolves_csv(db: &Pool<Sqlite>, server: &GuildId, user: &Csv) {
match sqlx::query_as::<_, Wolves>(
"
INSERT OR REPLACE INTO wolves (id_wolves, email)
VALUES (?1, ?2)
",
)
.bind(*server.as_u64() as i64)
.bind(&user.id_member)
.fetch_one(db)
.bind(&user.wolves.id_wolves)
.bind(&user.wolves.email)
.fetch_optional(db)
.await
{
Ok(acc) => acc.id_wolves,
Err(_) => String::new(),
};
Ok(_) => {}
Err(e) => {
println!("Failure to insert into {} {:?}", server.as_u64(), user.wolves);
println!("{:?}", e);
}
}
match sqlx::query_as::<_, Accounts>(
match sqlx::query_as::<_, ServerMembers>(
"
INSERT OR REPLACE INTO accounts (server, id_wolves, id_member, email, expiry)
VALUES (?1, ?2, ?3, ?4, ?5)
INSERT OR REPLACE INTO server_members (server, id_wolves, expiry)
VALUES (?1, ?2, ?3)
",
)
.bind(*server.as_u64() as i64)
.bind(&existing)
.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,
}
async fn get_skynet(db: &Pool<Sqlite>, config: &Config) {
let url = format!("{}/ldap/discord?auth={}", &config.ldap_api, &config.auth);
if let Ok(result) = surf::get(url).recv_json::<Vec<SkynetResult>>().await {
for user in result {
add_users_skynet(db, &config.skynet_server, &user).await;
}
}
}
async fn add_users_skynet(db: &Pool<Sqlite>, server: &GuildId, user: &SkynetResult) {
match sqlx::query_as::<_, Wolves>(
"
UPDATE wolves
SET discord = ?
WHERE id_wolves = ?
",
)
.bind(&user.discord)
.bind(&user.id_member)
.bind(&user.email)
.bind(&user.expiry)
.fetch_optional(db)
.await
{
@ -109,69 +159,9 @@ async fn add_users_wolves_csv(db: &Pool<Sqlite>, server: &GuildId, user: &Accoun
}
}
#[derive(Debug, Deserialize)]
pub struct SkynetResult {
discord: String,
id_wolves: String,
id_member: String,
}
async fn get_skynet(db: &Pool<Sqlite>, config: &Config) {
let url = format!("{}/ldap/discord?auth={}", &config.ldap_api, &config.auth);
if let Ok(result) = surf::get(url).recv_json::<Vec<SkynetResult>>().await {
for user in result {
add_users_skynet(db, &config.skynet_server, &user).await;
}
}
}
async fn add_users_skynet(db: &Pool<Sqlite>, server: &GuildId, user: &SkynetResult) {
if !user.id_wolves.is_empty() {
match sqlx::query_as::<_, Accounts>(
"
UPDATE accounts
SET discord = ?
WHERE server = ? AND id_wolves = ?
",
)
.bind(&user.discord)
.bind(*server.as_u64() as i64)
.bind(&user.id_wolves)
.fetch_optional(db)
.await
{
Ok(_) => {}
Err(e) => {
println!("Failure to insert into {} {:?}", server.as_u64(), user);
println!("{:?}", e);
}
}
}
if !user.id_member.is_empty() {
match sqlx::query_as::<_, Accounts>(
"
UPDATE accounts
SET discord = ?
WHERE server = ? AND id_member = ?
",
)
.bind(&user.discord)
.bind(*server.as_u64() as i64)
.bind(&user.id_member)
.fetch_optional(db)
.await
{
Ok(_) => {}
Err(e) => {
println!("Failure to insert into {} {:?}", server.as_u64(), user);
println!("{:?}", e);
}
}
}
}
#[derive(Debug, Deserialize)]
struct WolvesResult {
pub id_wolves: String,
pub id_member: String,
pub email: String,
pub expiry: String,
}
@ -186,7 +176,6 @@ async fn get_wolves(db: &Pool<Sqlite>) {
// get the data here
let result: Vec<WolvesResult> = vec![WolvesResult {
id_wolves: "12345".to_string(),
id_member: "166425".to_string(),
email: "ul.wolves2@brendan.ie".to_string(),
expiry: "2024-08-31".to_string(),
}];
@ -198,43 +187,40 @@ async fn get_wolves(db: &Pool<Sqlite>) {
}
async fn add_users_wolves(db: &Pool<Sqlite>, server: &GuildId, user: &WolvesResult) {
match sqlx::query_as::<_, Accounts>(
// expiry
match sqlx::query_as::<_, Wolves>(
"
UPDATE accounts
SET id_wolves = ?
WHERE server = ? AND id_member = ?
INSERT OR REPLACE INTO wolves (id_wolves, email)
VALUES (?1, ?2)
",
)
.bind(&user.id_wolves)
.bind(*server.as_u64() as i64)
.bind(&user.id_member)
.bind(&user.email)
.fetch_optional(db)
.await
{
Ok(_) => {}
Err(e) => {
println!("Failure to update into {} {:?}", server.as_u64(), user);
println!("Failure to insert into Wolves {} {:?}", server.as_u64(), user);
println!("{:?}", e);
}
}
match sqlx::query_as::<_, Accounts>(
match sqlx::query_as::<_, ServerMembers>(
"
INSERT OR REPLACE INTO accounts (server, id_wolves, id_member, email, expiry)
VALUES (?1, ?2, ?3, ?4, ?5)
INSERT OR REPLACE INTO server_members (server, id_wolves, expiry)
VALUES (?1, ?2, ?3)
",
)
.bind(*server.as_u64() as i64)
.bind(&user.id_wolves)
.bind(&user.id_member)
.bind(&user.email)
.bind(&user.expiry)
.fetch_optional(db)
.await
{
Ok(_) => {}
Err(e) => {
println!("Failure to insert into {} {:?}", server.as_u64(), user);
println!("Failure to insert into ServerMembers {} {:?}", server.as_u64(), user);
println!("{:?}", e);
}
}