putz u in dhe washing machin and spins ur bsky pofile pictuer !!! :D
apply offset based on did
+35
-20
+1
Cargo.lock
+1
Cargo.lock
+1
Cargo.toml
+1
Cargo.toml
···
15
15
image = { version = "0.25.9", default-features = false, features = ["default-formats"] }
16
16
imageproc = { version = "0.26.0", default-features = false }
17
17
jacquard = { version = "0.9.5", default-features = false, features = ["api_bluesky", "cache"] }
18
+
sha2 = { version = "0.10.9", default-features = false, features = ["std"] }
18
19
tokio = "1.49.0"
+3
-3
README.md
+3
-3
README.md
···
10
10
11
11
the identifier can be your handle or DID.
12
12
13
-
the program rotates your profile picture to the time of day, at 06:00 it'll be
14
-
90 degrees, at 12:00 it'll be 180 degrees, at 18:00 it'll be 270 degrees, at 00:00
15
-
it'll be 0 degrees.
13
+
the program rotates your profile picture throughout the day, in accordance with
14
+
the current time of day (so 12:00 -> 180, 18:00 -> 270), plus a random offset based
15
+
on your DID.
16
16
17
17
the sanctioned way of running this program is as follows:
18
18
+30
-17
src/main.rs
+30
-17
src/main.rs
···
13
13
identity::JacquardResolver,
14
14
types::{aturi::AtUri, blob::MimeType},
15
15
};
16
+
use sha2::{Digest, Sha256};
16
17
use std::{
17
18
env,
18
19
io::Cursor,
···
47
48
process::exit(1);
48
49
}
49
50
50
-
fn compute_angle() -> i32 {
51
-
const MS_PER_DAY: i128 = 86_400_000;
52
-
let now_ms = match SystemTime::now().duration_since(UNIX_EPOCH) {
53
-
Ok(dur) => dur.as_secs() as i128 * 1000 + dur.subsec_millis() as i128,
54
-
Err(e) => -((e.duration().as_secs() as i128) * 1000 + e.duration().subsec_millis() as i128),
55
-
};
51
+
fn calculate_offset_from_did<S: AsRef<str>>(did: S) -> i32 {
52
+
let mut hasher = Sha256::new();
53
+
hasher.update(did.as_ref().to_lowercase().as_bytes());
56
54
57
-
// make sure issa positive. i love spreading positivity everywhere i go!!! :D
58
-
let days = (now_ms).div_euclid(MS_PER_DAY);
59
-
let reference_ms = days * MS_PER_DAY;
55
+
let digest = hasher.finalize();
56
+
let arr: [u8; 8] = digest[0..8].try_into().unwrap();
57
+
let v = u64::from_le_bytes(arr);
60
58
61
-
let elapsed = now_ms - reference_ms;
62
-
let ms_today = ((elapsed % MS_PER_DAY) + MS_PER_DAY) % MS_PER_DAY;
59
+
(v % 360) as i32
60
+
}
63
61
64
-
let fraction_of_day = (ms_today as f64) / (MS_PER_DAY as f64);
65
-
let angle = (fraction_of_day * 360.0).floor() as i32;
62
+
fn compute_angle<S: AsRef<str>>(did: S) -> i32 {
63
+
const MS_PER_DAY: u128 = 86_400_000;
64
+
let now_ms = SystemTime::now()
65
+
.duration_since(UNIX_EPOCH)
66
+
.unwrap_or_else(|e| {
67
+
eprintln!("warning: system time before epoch: {:?}", e);
68
+
std::time::Duration::from_millis(0)
69
+
})
70
+
.as_millis();
66
71
67
-
((angle % 360) + 360) % 360
72
+
let ms_today = now_ms % MS_PER_DAY;
73
+
let time_angle = ((ms_today * 360) / MS_PER_DAY) as i32;
74
+
75
+
let did_offset = calculate_offset_from_did(did);
76
+
let final_angle = (time_angle + did_offset) % 360;
77
+
78
+
println!(
79
+
"computed angle: time_angle={} did_offset={} final_angle={}",
80
+
time_angle, did_offset, final_angle
81
+
);
82
+
final_angle
68
83
}
69
84
70
85
fn rotate_image(image: DynamicImage, degrees: i32, bg_color: image::Rgba<u8>) -> image::RgbaImage {
···
206
221
process::exit(1);
207
222
});
208
223
209
-
let angle = compute_angle();
224
+
let angle = compute_angle(&auth.did);
210
225
if let Some(prev) = read_state() {
211
226
if prev == angle {
212
227
println!("profile picture is already at {} degrees", angle);
···
224
239
}
225
240
226
241
update_avatar(rotated, &agent, &mime_type).await;
227
-
228
242
write_state(angle);
229
-
println!("rotated profile picture by {} degrees", angle);
230
243
}