gitweb.ps.run Git - chirp/blob - src/main.zig

   1 const std = @import("std");
   2 const lmdb = @import("lmdb");
   3 const db = @import("db");
   4 const http = @import("http");
   5
   6 // db {{{
   7
   8 const Db = struct {
   9     fn users(txn: lmdb.Txn) !db.Db(UserId, User) {
  10         return try db.Db(UserId, User).init(txn, "users");
  11     }
  12     fn user_ids(txn: lmdb.Txn) !db.Db(Username, UserId) {
  13         return try db.Db(Username, UserId).init(txn, "user_ids");
  14     }
  15     fn sessions(txn: lmdb.Txn) !db.Db(SessionToken, UserId) {
  16         return try db.Db(SessionToken, UserId).init(txn, "sessions");
  17     }
  18     fn posts(txn: lmdb.Txn) !db.Db(PostId, Post) {
  19         return try db.Db(PostId, Post).init(txn, "posts");
  20     }
  21 };
  22
  23 // }}}
  24
  25 // content {{{
  26
  27 const User = struct {
  28     // TODO: choose sizes
  29     id: UserId,
  30     name: Username,
  31     display_name: DisplayName,
  32     password_hash: PasswordHash,
  33     posts: PostList,
  34     following: UserList,
  35     followers: UserList,
  36
  37     post_lists: PostListList,
  38     feeds: UserListList,
  39 };
  40
  41 const Post = struct {
  42     id: PostId,
  43     parent_id: ?PostId,
  44     quote_id: ?PostId,
  45
  46     user_id: UserId,
  47     time: Timestamp,
  48
  49     upvotes: u64 = 0,
  50     downvotes: u64 = 0,
  51     votes: VoteList,
  52     comments: PostList,
  53     quotes: PostList,
  54
  55     text: PostText,
  56 };
  57
  58 const SavedPostList = struct {
  59     name: Name,
  60     list: PostList,
  61 };
  62 const SavedUserList = struct {
  63     name: Name,
  64     list: UserList,
  65 };
  66
  67 const Vote = struct {
  68     const Kind = enum { Up, Down };
  69
  70     kind: Kind,
  71     time: Timestamp,
  72 };
  73
  74 const Id = u64;
  75 const Login = struct {
  76     user: User,
  77     session_token: SessionToken,
  78 };
  79 const Name = std.BoundedArray(u8, 32);
  80 const UserId = enum(u64) { _ };
  81 const PostId = enum(u64) { _ };
  82 const Timestamp = i64;
  83 const Username = std.BoundedArray(u8, 32);
  84 const DisplayName = std.BoundedArray(u8, 64);
  85 const PasswordHash = std.BoundedArray(u8, 128);
  86 const SessionToken = u64;
  87 const CookieValue = std.BoundedArray(u8, 128);
  88 const PostText = std.BoundedArray(u8, 1024);
  89 const PostList = db.Set(PostId);
  90 const UserList = db.Set(UserId);
  91 const VoteList = db.SetList(UserId, Vote);
  92 const PostListList = db.List(SavedPostList);
  93 const UserListList = db.List(SavedUserList);
  94
  95 fn parse_enum(comptime E: type, buf: []const u8, base: u8) !E {
  96     return @enumFromInt(try std.fmt.parseUnsigned(@typeInfo(E).Enum.tag_type, buf, base));
  97 }
  98
  99 // https://developer.mozilla.org/en-US/docs/Glossary/Percent-encoding
 100 fn reencode(text: []const u8) !PostText {
 101     var result = try PostText.init(0);
 102
 103     const len = @min(text.len, 1024); // TODO: PostText length
 104
 105     var idx: usize = 0;
 106     while (idx < len) : (idx += 1) {
 107         const c = text[idx];
 108         if (c == '+') {
 109             try result.append(' ');
 110         } else if (c == '%') {
 111             // special case of &#...
 112             // assume only &#, no &#x
 113             if (idx + 6 < text.len and std.mem.eql(u8, text[idx .. idx + 6], "%26%23")) {
 114                 const num_start = idx + 6;
 115                 var num_end = num_start;
 116                 while (num_end < text.len and std.ascii.isDigit(text[num_end])) {
 117                     num_end += 1;
 118                 }
 119
 120                 if (num_end + 2 < text.len and
 121                     text[num_end] == '%' and
 122                     text[num_end + 1] == '3' and
 123                     std.ascii.toLower(text[num_end + 2]) == 'b')
 124                 {
 125                     try std.fmt.format(result.writer(), "&#{s};", .{text[num_start..num_end]});
 126                     idx = num_end + 2;
 127                     continue;
 128                 }
 129             }
 130
 131             try std.fmt.format(result.writer(), "&#x{s};", .{text[idx + 1 .. idx + 3]});
 132             idx += 2;
 133         } else {
 134             try result.append(c);
 135         }
 136     }
 137
 138     return result;
 139 }
 140
 141 fn decode(text: []const u8) !std.BoundedArray(u8, 32) {
 142     var result = try std.BoundedArray(u8, 32).init(0);
 143
 144     const max_len = @min(text.len, 1024); // TODO: PostText length
 145
 146     var idx: usize = 0;
 147     var len: usize = 0;
 148     while (len < max_len and idx < text.len) : ({
 149         idx += 1;
 150         len += 1;
 151     }) {
 152         const c = text[idx];
 153         if (c == '+') {
 154             try result.append(' ');
 155         } else if (c == '%') {
 156             if (idx + 2 < text.len) {
 157                 try std.fmt.format(result.writer(), "{c}", .{try std.fmt.parseUnsigned(u8, text[idx + 1 .. idx + 3], 16)});
 158             }
 159             idx += 2;
 160         } else {
 161             try result.append(c);
 162         }
 163     }
 164
 165     return result;
 166 }
 167
 168 const Chirp = struct {
 169     pub fn hash_password(password: []const u8) !PasswordHash {
 170         var hash_buffer = try PasswordHash.init(128);
 171
 172         // TODO: choose buffer size
 173         // TODO: dont allocate on stack, maybe zero memory?
 174         var buffer: [1024 * 10]u8 = undefined;
 175         var alloc = std.heap.FixedBufferAllocator.init(&buffer);
 176
 177         // TODO: choose limits
 178         const result = try std.crypto.pwhash.argon2.strHash(password, .{
 179             .allocator = alloc.allocator(),
 180             .params = std.crypto.pwhash.argon2.Params.fromLimits(1000, 1024),
 181         }, hash_buffer.slice());
 182
 183         try hash_buffer.resize(result.len);
 184
 185         return hash_buffer;
 186     }
 187
 188     pub fn verify_password(password: []const u8, hash: PasswordHash) bool {
 189         var buffer: [1024 * 10]u8 = undefined;
 190         var alloc = std.heap.FixedBufferAllocator.init(&buffer);
 191
 192         if (std.crypto.pwhash.argon2.strVerify(hash.constSlice(), password, .{
 193             .allocator = alloc.allocator(),
 194         })) {
 195             return true;
 196         } else |err| {
 197             std.debug.print("verify error: {}\n", .{err});
 198             return false;
 199         }
 200     }
 201
 202     pub fn register_user(env: *lmdb.Env, username: []const u8, password: []const u8) !bool {
 203         const username_array = try Username.fromSlice(username);
 204         const display_name = try DisplayName.fromSlice(username);
 205
 206         const txn = try env.txn();
 207         defer txn.commit() catch |err| {
 208             std.debug.print("error registering user: {}\n", .{err});
 209         };
 210
 211         const users = try Db.users(txn);
 212         const user_ids = try Db.user_ids(txn);
 213
 214         if (try user_ids.has(username_array)) {
 215             return false;
 216         } else {
 217             const user_id = try db.Prng.gen(users.dbi, UserId);
 218
 219             try users.put(user_id, User{
 220                 .id = user_id,
 221                 .name = username_array,
 222                 .display_name = display_name,
 223                 .password_hash = try hash_password(password),
 224                 .posts = try PostList.init(txn),
 225                 .following = try UserList.init(txn),
 226                 .followers = try UserList.init(txn),
 227                 .post_lists = try PostListList.init(txn),
 228                 .feeds = try UserListList.init(txn),
 229             });
 230
 231             try user_ids.put(username_array, user_id);
 232
 233             return true;
 234         }
 235     }
 236
 237     pub fn login_user(
 238         env: *lmdb.Env,
 239         username: []const u8,
 240         password: []const u8,
 241     ) !SessionToken {
 242         const username_array = try Username.fromSlice(username);
 243
 244         const txn = try env.txn();
 245         defer txn.commit() catch {};
 246
 247         const user_ids = try Db.user_ids(txn);
 248         const user_id = try user_ids.get(username_array);
 249         std.debug.print("user logging in, id: {}\n", .{user_id});
 250
 251         const users = try Db.users(txn);
 252         const user = try users.get(user_id);
 253
 254         if (verify_password(password, user.password_hash)) {
 255             const sessions = try Db.sessions(txn);
 256             const session_token = try db.Prng.gen(sessions.dbi, SessionToken);
 257             try sessions.put(session_token, user_id);
 258             return session_token;
 259         } else {
 260             return error.IncorrectPassword;
 261         }
 262     }
 263
 264     fn logout_user(env: *lmdb.Env, session_token: SessionToken) !void {
 265         const txn = try env.txn();
 266         defer txn.commit() catch {};
 267
 268         const sessions = try Db.sessions(txn);
 269         try sessions.del(session_token);
 270     }
 271
 272     fn append_post(env: *lmdb.Env, user_id: UserId, post_list: PostList, parent_id: ?PostId, quote_id: ?PostId, text: []const u8) !void {
 273         var post_id: PostId = undefined;
 274
 275         // TODO: do this in one commit
 276
 277         var txn: lmdb.Txn = undefined;
 278         {
 279             // create post
 280             txn = try env.txn();
 281             defer txn.commit() catch {};
 282
 283             const posts = try Db.posts(txn);
 284             post_id = try db.Prng.gen(posts.dbi, PostId);
 285
 286             const decoded_text = try reencode(text);
 287             try posts.put(post_id, Post{
 288                 .id = post_id,
 289                 .parent_id = parent_id,
 290                 .quote_id = quote_id,
 291                 .user_id = user_id,
 292                 .time = std.time.timestamp(),
 293                 .votes = try VoteList.init(txn),
 294                 .comments = try PostList.init(txn),
 295                 .quotes = try PostList.init(txn),
 296                 .text = decoded_text,
 297             });
 298         }
 299
 300         {
 301             // append to user's posts
 302             txn = try env.txn();
 303             defer txn.commit() catch {};
 304
 305             var posts_view = try post_list.open(txn);
 306             try posts_view.append(post_id);
 307         }
 308
 309         if (quote_id != null) {
 310             txn = try env.txn();
 311             defer txn.commit() catch {};
 312
 313             const posts = try Db.posts(txn);
 314             const quote_post = try posts.get(quote_id.?);
 315             var quotes = try quote_post.quotes.open(txn);
 316             try quotes.append(post_id);
 317         }
 318     }
 319
 320     fn post(env: *lmdb.Env, user_id: UserId, text: []const u8) !void {
 321         const txn = try env.txn();
 322
 323         const users = try Db.users(txn);
 324         const user = try users.get(user_id);
 325
 326         txn.abort();
 327
 328         try append_post(env, user_id, user.posts, null, null, text);
 329     }
 330
 331     fn comment(env: *lmdb.Env, user_id: UserId, parent_post_id: PostId, text: []const u8) !void {
 332         const txn = try env.txn();
 333
 334         const posts = try Db.posts(txn);
 335         const parent_post = try posts.get(parent_post_id);
 336
 337         txn.abort();
 338
 339         try append_post(env, user_id, parent_post.comments, parent_post_id, null, text);
 340     }
 341
 342     fn quote(env: *lmdb.Env, user_id: UserId, quote_post_id: PostId, text: []const u8) !void {
 343         const txn = try env.txn();
 344
 345         const users = try Db.users(txn);
 346         const user = try users.get(user_id);
 347
 348         txn.abort();
 349
 350         try append_post(env, user_id, user.posts, null, quote_post_id, text);
 351     }
 352
 353     fn vote(env: *lmdb.Env, post_id: PostId, user_id: UserId, kind: Vote.Kind) !void {
 354         const txn = try env.txn();
 355         defer txn.commit() catch {};
 356
 357         const posts = try Db.posts(txn);
 358
 359         var p = try posts.get(post_id);
 360         var votes_view = try p.votes.open(txn);
 361
 362         var add_vote = true;
 363
 364         if (try votes_view.has(user_id)) {
 365             const old_vote = try votes_view.get(user_id);
 366
 367             add_vote = old_vote.kind != kind;
 368
 369             try votes_view.del(user_id);
 370
 371             switch (old_vote.kind) {
 372                 .Up => p.upvotes -= 1,
 373                 .Down => p.downvotes -= 1,
 374             }
 375             try posts.put(post_id, p);
 376         }
 377
 378         if (add_vote) {
 379             try votes_view.append(user_id, Vote{
 380                 .kind = kind,
 381                 .time = std.time.timestamp(),
 382             });
 383
 384             if (kind == .Up) {
 385                 p.upvotes += 1;
 386             } else {
 387                 p.downvotes += 1;
 388             }
 389             try posts.put(post_id, p);
 390         }
 391     }
 392
 393     fn follow(env: *lmdb.Env, user_id: UserId, user_id_to_follow: UserId) !void {
 394         const txn = try env.txn();
 395         defer txn.commit() catch {};
 396
 397         const users = try Db.users(txn);
 398
 399         const user = try users.get(user_id);
 400         const user_to_follow = try users.get(user_id_to_follow);
 401
 402         var user_following = try user.following.open(txn);
 403         var user_to_follow_followers = try user_to_follow.followers.open(txn);
 404
 405         if ((user_following.has(user_id_to_follow) catch false) and (user_to_follow_followers.has(user_id) catch false)) {
 406             try user_following.del(user_id_to_follow);
 407             try user_to_follow_followers.del(user_id);
 408         } else if (!(user_following.has(user_id_to_follow) catch true) and !(user_to_follow_followers.has(user_id) catch true)) {
 409             try user_following.append(user_id_to_follow);
 410             try user_to_follow_followers.append(user_id);
 411         } else {
 412             std.debug.print("Something went wrong when trying to unfollow\n", .{});
 413         }
 414     }
 415
 416     fn get_session_user_id(env: *lmdb.Env, session_token: SessionToken) !UserId {
 417         const txn = try env.txn();
 418         defer txn.abort();
 419
 420         const sessions = try Db.sessions(txn);
 421
 422         return try sessions.get(session_token);
 423     }
 424
 425     fn get_user(env: *lmdb.Env, user_id: UserId) !User {
 426         const txn = try env.txn();
 427         defer txn.abort();
 428
 429         const users = try Db.users(txn);
 430         return try users.get(user_id);
 431     }
 432 };
 433
 434 // }}}
 435
 436 // html {{{
 437 fn html_form(res: *http.Response, comptime fmt_action: []const u8, args_action: anytype, inputs: anytype) !void {
 438     try res.write("<form action=\"", .{});
 439     try res.write(fmt_action, args_action);
 440     try res.write("\" method=\"post\">", .{});
 441
 442     inline for (inputs) |input| {
 443         switch (@typeInfo(@TypeOf(input))) {
 444             .Struct => {
 445                 try res.write("<input ", .{});
 446                 try res.write(input[0], input[1]);
 447                 try res.write(" />", .{});
 448             },
 449             else => {
 450                 try res.write("<input ", .{});
 451                 try res.write(input, .{});
 452                 try res.write(" />", .{});
 453             },
 454         }
 455     }
 456
 457     try res.write("</form>", .{});
 458 }
 459 // }}}
 460
 461 // write {{{
 462 const TimeStr = std.BoundedArray(u8, 256);
 463 // fn time_str(_t: i64) TimeStr {
 464 //     var result = TimeStr.init(0) catch unreachable;
 465
 466 //     const nthSecond: u64 = @intCast(_t);
 467 //     const nthDay = nthSecond / std.time.s_per_day;
 468 //     const secondInDay = nthSecond - nthDay * std.time.s_per_day;
 469 //     const hourInDay = secondInDay / std.time.s_per_hour;
 470 //     const secondInHour = secondInDay % std.time.s_per_hour;
 471 //     const minuteInHour = secondInHour / 60;
 472 //     const secondInMinute = secondInDay % std.time.s_per_min;
 473
 474 //     const nthYear = nthDay / 365; // maybe check
 475 //     const year = 1970 + nthYear;
 476 //     const leapdays = year / 4 - year / 100 + year / 400;
 477 //     const secondInYear = nthSecond - (nthYear * 365 + leapdays) * std.time.s_per_day;
 478 //     const dayInYear = secondInYear / std.time.s_per_day;
 479
 480 //     std.fmt.format(result.writer(), "<time>{:0>2}:{:0>2}:{:0>2} {:0>2}.{:0>2}.{:0>4} UTC</time>", .{
 481 //         hourInDay,
 482 //         minuteInHour,
 483 //         secondInMinute,
 484 //         dayInYear,
 485 //         0,
 486 //         year,
 487 //     }) catch unreachable;
 488
 489 //     return result;
 490 // }
 491 // http://howardhinnant.github.io/date_algorithms.html
 492 fn time_str(_t: i64) TimeStr {
 493     const t: u64 = @intCast(_t);
 494     var result = TimeStr.init(0) catch unreachable;
 495
 496     const nD = @divFloor(t, std.time.s_per_day);
 497     const z: u64 = nD + 719468;
 498     const era: u64 = (if (z >= 0) z else z - 146096) / 146097;
 499     const doe: u64 = z - era * 146097; // [0, 146096]
 500     const yoe: u64 = (doe - doe / 1460 + doe / 36524 - doe / 146096) / 365; // [0, 399]
 501     const Y: u64 = yoe + era * 400;
 502     const doy: u64 = doe - (365 * yoe + yoe / 4 - yoe / 100); // [0, 365]
 503     const mp: u64 = (5 * doy + 2) / 153; // [0, 11]
 504     const D: u64 = doy - (153 * mp + 2) / 5 + 1; // [1, 31]
 505     const M: u64 = if (mp < 10) mp + 3 else mp - 9;
 506
 507     const h: u64 = @divFloor(t - nD * std.time.s_per_day, std.time.s_per_hour);
 508     const m: u64 = @divFloor(t - nD * std.time.s_per_day - h * std.time.s_per_hour, std.time.s_per_min);
 509     const s: u64 = t - nD * std.time.s_per_day - h * std.time.s_per_hour - m * std.time.s_per_min;
 510
 511     std.fmt.format(result.writer(), "<time><span>{:0>4}-{:0>2}-{:0>2} {:0>2}:{:0>2}:{:0>2} UTC</span><script>document.currentScript.parentElement.innerHTML=new Date({}).toLocaleString()</script></time>", .{ Y, M, D, h, m, s, t * 1000 }) catch unreachable;
 512
 513     return result;
 514 }
 515 fn write_header(res: *http.Response, logged_in: ?Login) !void {
 516     if (logged_in) |login| {
 517         try res.write(
 518             \\<a href="/">Home</a><br />
 519         , .{});
 520         try res.write(
 521             \\<a href="/user/{s}">Profile</a><br />
 522         , .{login.user.name.constSlice()});
 523         try res.write(
 524             \\<a href="/post">Post</a><br />
 525         , .{});
 526         try html_form(res, "/logout", .{}, .{
 527             \\type="submit" value="Logout"
 528         });
 529         try html_form(res, "/quit", .{}, .{
 530             \\type="submit" value="Quit"
 531         });
 532         try res.write("<br /><br />", .{});
 533     } else {
 534         try res.write(
 535             \\<a href="/">Home</a><br />
 536             \\<form action="/register" method="post">
 537             \\<input type="text" name="username" />
 538             \\<input type="password" name="password" />
 539             \\<input type="submit" value="Register" />
 540             \\</form>
 541             \\<form action="/login" method="post">
 542             \\<input type="text" name="username" />
 543             \\<input type="password" name="password" />
 544             \\<input type="submit" value="Login" />
 545             \\</form>
 546         , .{});
 547         try html_form(res, "/quit", .{}, .{
 548             \\type="submit" value="Quit"
 549         });
 550         try res.write("<br /><br />", .{});
 551     }
 552 }
 553 fn write_start(res: *http.Response) !void {
 554     try res.write(
 555         \\<!doctype html>
 556         \\<html>
 557         \\<head>
 558         \\<link rel="icon" href="data:image/svg+xml,<svg xmlns=%22http://www.w3.org/2000/svg%22 viewBox=%220 0 100 100%22><text y=%22.9em%22 font-size=%2290%22>&#128035;</text></svg>">
 559         \\<style>
 560         \\  form {
 561         \\    display: inline-block;
 562         \\  }
 563         // \\  .toggle > form > input:placeholder-shown {
 564         // \\    display: none;
 565         // \\  }
 566         // \\  .toggle:hover > form > input {
 567         // \\    display: inline-block;
 568         // \\  }
 569         // \\  .toggle > form > input:placeholder-shown + input {
 570         // \\    display: none;
 571         // \\  }
 572         // \\  .toggle:hover > form > input + input {
 573         // \\    display: inline-block;
 574         // \\  }
 575         \\</style>
 576         \\</head>
 577         \\<body>
 578     , .{});
 579 }
 580 fn write_end(res: *http.Response) !void {
 581     try res.write("</body></html>", .{});
 582 }
 583 fn write_post(res: *http.Response, txn: lmdb.Txn, logged_in: ?Login, post_id: PostId, options: struct { recurse: u8 = 0, show_comment_field: bool = false }) !void {
 584     const posts = try Db.posts(txn);
 585     const post = posts.get(post_id) catch {
 586         res.redirect("/") catch {};
 587         return;
 588     };
 589     const users = try Db.users(txn);
 590     const user = try users.get(post.user_id);
 591
 592     try res.write(
 593         \\<div>
 594         \\<span><a href="/user/{s}">{s}</a> {s}</span><br />
 595         \\<span>{s}</span><br />
 596     , .{ user.name.constSlice(), user.display_name.constSlice(), time_str(post.time).constSlice(), post.text.constSlice() });
 597
 598     if (post.quote_id) |quote_id| {
 599         try res.write("<div style=\"border: 1px solid black;\">", .{});
 600         if (options.recurse > 0) {
 601             try write_post(res, txn, logged_in, quote_id, .{ .recurse = options.recurse - 1 });
 602         } else {
 603             try res.write("<a href=\"/post/{x}\">...</a>", .{@intFromEnum(quote_id)});
 604         }
 605         try res.write("</div>", .{});
 606     }
 607
 608     const comments_view = try post.comments.open(txn);
 609     const quotes_view = try post.quotes.open(txn);
 610     const votes_view = try post.votes.open(txn);
 611
 612     // Votes
 613     const vote: ?Vote = if (logged_in != null and try votes_view.has(logged_in.?.user.id)) try votes_view.get(logged_in.?.user.id) else null;
 614
 615     if (vote != null and vote.?.kind == .Up) {
 616         try html_form(res, "/upvote", .{}, .{
 617             .{ "type=\"hidden\" value=\"{x}\" name=\"post_id\"", .{@intFromEnum(post.id)} },
 618             .{ "type=\"submit\" value=\"&#x2B06; {}\"", .{post.upvotes} },
 619         });
 620     } else {
 621         try html_form(res, "/upvote", .{}, .{
 622             .{ "type=\"hidden\" value=\"{x}\" name=\"post_id\"", .{@intFromEnum(post.id)} },
 623             .{ "type=\"submit\" value=\"&#x21E7; {}\"", .{post.upvotes} },
 624         });
 625     }
 626     if (vote != null and vote.?.kind == .Down) {
 627         try html_form(res, "/downvote", .{}, .{
 628             .{ "type=\"hidden\" value=\"{x}\" name=\"post_id\"", .{@intFromEnum(post.id)} },
 629             .{ "type=\"submit\" value=\"&#x2B07; {}\"", .{post.downvotes} },
 630         });
 631     } else {
 632         try html_form(res, "/downvote", .{}, .{
 633             .{ "type=\"hidden\" value=\"{x}\" name=\"post_id\"", .{@intFromEnum(post.id)} },
 634             .{ "type=\"submit\" value=\"&#x21E9; {}\"", .{post.downvotes} },
 635         });
 636     }
 637
 638     // Comment Count
 639     try res.write(
 640         \\<a href="/post/{x}">&#x1F4AD; {}</a>
 641     , .{ @intFromEnum(post.id), comments_view.len() });
 642
 643     // Quote
 644     try res.write(
 645         \\<a href="/quotes/{x}">&#x1F501; {}</a>
 646     , .{ @intFromEnum(post.id), quotes_view.len() });
 647     try res.write(
 648         \\<br />
 649     , .{});
 650
 651     // Save to List
 652     if (logged_in) |login| {
 653         const lists_view = try login.user.post_lists.open(txn);
 654         try res.write("<form action=\"/list_add\" method=\"post\">", .{});
 655         try res.write("<select name=\"list_id\">", .{});
 656         var it = lists_view.iterator();
 657         while (it.next()) |kv| {
 658             const name = kv.val.name;
 659             const id = kv.val.list.idx.?;
 660             try res.write("<option value=\"{x}\">{s}</option>", .{ id, name.constSlice() });
 661         }
 662         try res.write("</select>", .{});
 663         try res.write("<input type=\"hidden\" name=\"post_id\" value=\"{x}\"></input>", .{@intFromEnum(post_id)});
 664         try res.write("<input type=\"submit\" value=\"Save\"></input>", .{});
 665         try res.write("</form>", .{});
 666     }
 667
 668     // Comment field
 669     // TODO: maybe always show comment field and prompt for login
 670     if (options.show_comment_field and logged_in != null) {
 671         try res.write("<br />", .{});
 672         try html_form(res, "/comment", .{}, .{
 673             .{ "type=\"hidden\" value=\"{x}\" name=\"post_id\"", .{@intFromEnum(post.id)} },
 674             "type=\"text\" name=\"text\" placeholder=\"Text\"",
 675             "type=\"submit\" value=\"Comment\"",
 676         });
 677         try res.write("<br />", .{});
 678     }
 679
 680     // Comments
 681     if (options.recurse > 0 and comments_view.len() > 0) {
 682         try res.write(
 683             \\<details{s}>
 684             \\<summary>Comments</summary>
 685         , .{if (options.recurse > 1) " open" else ""});
 686         try res.write("<div style=\"margin: 10px;\">", .{});
 687         var it = comments_view.iterator();
 688         var count: u8 = 0;
 689         while (it.next()) |comment_id| {
 690             try write_post(res, txn, logged_in, comment_id, .{ .recurse = options.recurse - 1 });
 691             try res.write("<br />", .{});
 692             if (options.recurse == 1) {
 693                 count += 1;
 694                 if (count >= 3) break;
 695             }
 696         }
 697         try res.write(
 698             \\</div>
 699             \\</details>
 700         , .{});
 701     }
 702
 703     try res.write(
 704         \\</div>
 705     , .{});
 706 }
 707 fn write_posts(res: *http.Response, txn: lmdb.Txn, logged_in: ?Login, post_list: PostList) !void {
 708     const posts_view = try post_list.open(txn);
 709
 710     var it = posts_view.reverse_iterator();
 711     while (it.next()) |post_id| {
 712         try write_post(res, txn, logged_in, post_id, .{ .recurse = 1 });
 713         try res.write("<br />", .{});
 714     }
 715 }
 716 fn write_timeline(res: *http.Response, txn: lmdb.Txn, logged_in: ?Login, user_list: UserList) !void {
 717     const users = try Db.users(txn);
 718     const posts = try Db.posts(txn);
 719
 720     var newest_post_ids = try std.BoundedArray(PostId, 10).init(0); // TODO: TimelinePostsCount
 721     var prev_newest_post: ?Post = null;
 722
 723     const following = try user_list.open(txn);
 724
 725     while (true) {
 726         var newest_post: ?Post = null;
 727
 728         var it = following.iterator();
 729         while (it.next()) |following_id| {
 730             const followed_user = try users.get(following_id);
 731             const followed_posts = try followed_user.posts.open(txn);
 732
 733             if (followed_posts.len() == 0) {
 734                 continue;
 735             }
 736
 737             var followed_posts_it = followed_posts.reverse_iterator();
 738             while (followed_posts_it.next()) |followed_post_id| {
 739                 const last_post = try posts.get(followed_post_id);
 740
 741                 if ((prev_newest_post == null or last_post.time < prev_newest_post.?.time) and (newest_post == null or newest_post.?.time < last_post.time)) {
 742                     newest_post = last_post;
 743                 }
 744             }
 745         }
 746         if (newest_post) |post| {
 747             newest_post_ids.append(post.id) catch break;
 748             prev_newest_post = post;
 749         } else {
 750             break;
 751         }
 752     }
 753
 754     for (newest_post_ids.constSlice()) |post_id| {
 755         try write_post(res, txn, logged_in, post_id, .{ .recurse = 1 });
 756         try res.write("<br />", .{});
 757     }
 758 }
 759 // }}}
 760
 761 fn list_users(env: lmdb.Env) !void {
 762     const txn = try env.txn();
 763     defer txn.abort();
 764
 765     const users = try Db.users(txn);
 766     var it = try users.iterator();
 767
 768     while (it.next()) |kv| {
 769         const key = kv.key;
 770         const user = kv.val;
 771         std.debug.print("[{}] {s}\n", .{ key, user.name.constSlice() });
 772     }
 773 }
 774 fn list_user_ids(env: lmdb.Env) !void {
 775     const txn = try env.txn();
 776     defer txn.abort();
 777
 778     const user_ids = try Db.user_ids(txn);
 779     var it = try user_ids.iterator();
 780
 781     while (it.next()) |kv| {
 782         const key = kv.key;
 783         const user_id = kv.val;
 784         std.debug.print("[{s}] {}\n", .{ key.constSlice(), user_id });
 785     }
 786 }
 787
 788 fn list_sessions(env: lmdb.Env) !void {
 789     const txn = try env.txn();
 790     defer txn.abort();
 791
 792     const sessions = try Db.sessions(txn);
 793     var it = try sessions.iterator();
 794
 795     while (it.next()) |kv| {
 796         const key = kv.key;
 797         const user_id = kv.val;
 798         std.debug.print("[{x}] {}\n", .{ key, user_id });
 799     }
 800 }
 801
 802 fn list_posts(env: lmdb.Env) !void {
 803     const txn = try env.txn();
 804     defer txn.abort();
 805
 806     const posts = try Db.posts(txn);
 807     var it = try posts.iterator();
 808
 809     while (it.next()) |kv| {
 810         const key = kv.key;
 811         const post = kv.val;
 812         std.debug.print("[{}] {s}\n", .{ key, post.text.constSlice() });
 813     }
 814 }
 815
 816 const ReqBufferSize = 4096;
 817 const ResHeadBufferSize = 1024 * 64;
 818 const ResBodyBufferSize = 1024 * 64;
 819
 820 pub fn main() !void {
 821     // server
 822     var server = try http.Server.init("::", 8080);
 823     defer server.deinit();
 824
 825     // lmdb
 826     var env = try lmdb.Env.open("db", 1024 * 1024 * 10);
 827     defer env.close();
 828
 829     std.debug.print("Users:\n", .{});
 830     try list_users(env);
 831     std.debug.print("User IDs:\n", .{});
 832     try list_user_ids(env);
 833     std.debug.print("Sessions:\n", .{});
 834     try list_sessions(env);
 835     std.debug.print("Posts:\n", .{});
 836     try list_posts(env);
 837
 838     try handle_connection(&server, &env);
 839     // const ThreadCount = 1;
 840     // var ts: [ThreadCount]std.Thread = undefined;
 841
 842     // for (0..ThreadCount) |i| {
 843     //     ts[i] = try std.Thread.spawn(.{}, handle_connection, .{ &server, &env });
 844     // }
 845     // for (0..ThreadCount) |i| {
 846     //     ts[i].join();
 847     // }
 848
 849     std.debug.print("done\n", .{});
 850 }
 851
 852 fn handle_connection(server: *http.Server, env: *lmdb.Env) !void {
 853     // TODO: static?
 854     var req_buffer: [ReqBufferSize]u8 = undefined;
 855     var res_head_buffer: [ResHeadBufferSize]u8 = undefined;
 856     var res_body_buffer: [ResBodyBufferSize]u8 = undefined;
 857
 858     accept: while (true) {
 859         server.wait();
 860
 861         while (try server.next_request(&req_buffer)) |*_req| {
 862             var req: *http.Request = @constCast(_req);
 863             // std.debug.print("[{}]: {s}\n", .{ req.method, req.target });
 864
 865             // reponse
 866             var res = http.Response.init(req.fd, &res_head_buffer, &res_body_buffer);
 867
 868             // check session token
 869             var logged_in: ?Login = null;
 870
 871             if (req.get_cookie("session_token")) |session_token_str| {
 872                 var remove_session_token = true;
 873
 874                 if (std.fmt.parseUnsigned(SessionToken, session_token_str, 16) catch null) |session_token| {
 875                     // const session_token = try std.fmt.parseUnsigned(SessionToken, session_token_str, 10);
 876                     // const session_token = std.mem.bytesToValue(SessionToken, session_token_str);
 877                     if (Chirp.get_session_user_id(env, session_token) catch null) |user_id| {
 878                         const txn = try env.txn();
 879                         defer txn.abort();
 880                         const users = try Db.users(txn);
 881
 882                         logged_in = .{
 883                             .user = try users.get(user_id),
 884                             .session_token = session_token,
 885                         };
 886
 887                         remove_session_token = false;
 888                     }
 889                 }
 890
 891                 if (remove_session_token) {
 892                     try res.add_header(
 893                         "Set-Cookie",
 894                         .{"session_token=deleted; Expires=Thu, 01 Jan 1970 00:00:00 GMT"},
 895                     );
 896                 }
 897             }
 898
 899             // TODO: refactor into functions
 900             // TODO: make sure we send a reply
 901
 902             // html
 903             if (req.method == .GET) {
 904                 try write_start(&res);
 905                 try write_header(&res, logged_in);
 906
 907                 const txn = try env.txn();
 908                 defer txn.abort();
 909
 910                 if (std.mem.startsWith(u8, req.target, "/user/")) {
 911                     const username = req.target[6..req.target.len];
 912
 913                     const user_ids = try Db.user_ids(txn);
 914                     if (user_ids.get(try Username.fromSlice(username))) |user_id| {
 915                         const users = try Db.users(txn);
 916                         const user = try users.get(user_id);
 917
 918                         const following = try user.following.open(txn);
 919                         const followers = try user.followers.open(txn);
 920
 921                         try res.write(
 922                             \\<h2 style="display: inline;"><a href="/user/{s}">{s}</a></h2>
 923                         , .{
 924                             user.name.constSlice(), user.display_name.constSlice(),
 925                         });
 926                         if (logged_in != null and user_id != logged_in.?.user.id) {
 927                             if (try followers.has(logged_in.?.user.id)) {
 928                                 try html_form(&res, "/follow", .{}, .{
 929                                     .{ "type=\"hidden\" name=\"user_id\" value=\"{x}\"", .{@intFromEnum(user_id)} },
 930                                     \\type="submit" value="Unfollow"
 931                                 });
 932                             } else {
 933                                 try html_form(&res, "/follow", .{}, .{
 934                                     .{ "type=\"hidden\" name=\"user_id\" value=\"{x}\"", .{@intFromEnum(user_id)} },
 935                                     \\type="submit" value="Follow"
 936                                 });
 937                             }
 938                         }
 939                         try res.write(
 940                             \\ <a href="/following/{s}">{} following</a>
 941                             \\ <a href="/followers/{s}">{} followers</a>
 942                             \\<br />
 943                         , .{
 944                             user.name.constSlice(), following.len(),
 945                             user.name.constSlice(), followers.len(),
 946                         });
 947
 948                         if (logged_in != null and user_id == logged_in.?.user.id) {
 949                             try res.write(
 950                                 \\<a href="/lists">Lists</a>
 951                                 \\<a href="/feeds">Feeds</a>
 952                                 \\<a href="/edit">Edit</a><br />
 953                                 \\<br />
 954                             , .{});
 955                         }
 956
 957                         try res.write("<br />", .{});
 958
 959                         try write_posts(&res, txn, logged_in, user.posts);
 960                     } else |err| {
 961                         try res.write(
 962                             \\<p>User not found [{}]</p>
 963                         , .{err});
 964                     }
 965                 } else if (std.mem.startsWith(u8, req.target, "/following/")) {
 966                     const username = req.target[11..req.target.len];
 967
 968                     const user_ids = try Db.user_ids(txn);
 969                     if (user_ids.get(try Username.fromSlice(username))) |user_id| {
 970                         const users = try Db.users(txn);
 971                         const user = try users.get(user_id);
 972
 973                         const following = try user.following.open(txn);
 974                         var it = following.iterator();
 975
 976                         try res.write(
 977                             \\<h2><a href="/user/{s}">{s}</a> follows:</h2>
 978                         , .{ user.name.constSlice(), user.display_name.constSlice() });
 979
 980                         while (it.next()) |following_id| {
 981                             const following_user = try users.get(following_id);
 982
 983                             try res.write(
 984                                 \\<a href="/user/{s}">{s}</a><br />
 985                             , .{ following_user.name.constSlice(), following_user.display_name.constSlice() });
 986                         }
 987                     } else |err| {
 988                         try res.write(
 989                             \\<p>User not found [{}]</p>
 990                         , .{err});
 991                     }
 992                 } else if (std.mem.startsWith(u8, req.target, "/followers/")) {
 993                     const username = req.target[11..req.target.len];
 994
 995                     const user_ids = try Db.user_ids(txn);
 996                     if (user_ids.get(try Username.fromSlice(username))) |user_id| {
 997                         const users = try Db.users(txn);
 998                         const user = try users.get(user_id);
 999
1000                         const followers = try user.followers.open(txn);
1001                         var it = followers.iterator();
1002
1003                         try res.write(
1004                             \\<h2><a href="/user/{s}">{s}</a> followers:</h2>
1005                         , .{ user.name.constSlice(), user.display_name.constSlice() });
1006
1007                         while (it.next()) |follower_id| {
1008                             const follower_user = try users.get(follower_id);
1009
1010                             try res.write(
1011                                 \\<a href="/user/{s}">{s}</a><br />
1012                             , .{ follower_user.name.constSlice(), follower_user.display_name.constSlice() });
1013                         }
1014                     } else |err| {
1015                         try res.write(
1016                             \\<p>User not found [{}]</p>
1017                         , .{err});
1018                     }
1019                 } else if (std.mem.startsWith(u8, req.target, "/post/")) {
1020                     const post_id_str = req.target[6..req.target.len];
1021                     const post_id = try parse_enum(PostId, post_id_str, 16);
1022
1023                     try write_post(&res, txn, logged_in, post_id, .{
1024                         .recurse = 3, // TODO: factor out
1025                         .show_comment_field = true,
1026                     });
1027                 } else if (std.mem.startsWith(u8, req.target, "/quotes/")) {
1028                     const post_id_str = req.target[8..req.target.len];
1029                     const post_id = try parse_enum(PostId, post_id_str, 16);
1030
1031                     const posts = try Db.posts(txn);
1032                     const post = try posts.get(post_id);
1033
1034                     const referer = if (req.get_header("Referer")) |ref| ref else req.target;
1035
1036                     try html_form(&res, "/quote", .{}, .{
1037                         .{ "type=\"hidden\" name=\"referer\" value=\"{s}\"", .{referer} },
1038                         .{ "type=\"hidden\" name=\"post_id\" value=\"{x}\"", .{@intFromEnum(post.id)} },
1039                         "type=\"text\" name=\"text\" placeholder=\"Text\"",
1040                         "type=\"submit\" value=\"Quote\"",
1041                     });
1042                     try res.write("<br />", .{});
1043
1044                     const quotes_view = try post.quotes.open(txn);
1045                     var it = quotes_view.iterator();
1046                     while (it.next()) |quote_id| {
1047                         try write_post(&res, txn, logged_in, quote_id, .{ .recurse = 1 });
1048                         try res.write("<br />", .{});
1049                     }
1050                 } else if (std.mem.startsWith(u8, req.target, "/list/")) {
1051                     const list_id_str = req.target[6..req.target.len];
1052                     const list_id = try std.fmt.parseUnsigned(PostListList.Index, list_id_str, 16);
1053
1054                     try write_posts(&res, txn, logged_in, PostList{ .idx = list_id });
1055                 } else if (std.mem.eql(u8, req.target, "/lists")) {
1056                     if (logged_in) |login| {
1057                         const post_lists_view = try login.user.post_lists.open(txn);
1058
1059                         try html_form(&res, "/new_list", .{}, .{
1060                             "type=\"text\" name=\"name\"",
1061                             "type=\"submit\" value=\"Add\"",
1062                         });
1063
1064                         try res.write("<br /><br />", .{});
1065
1066                         var it = post_lists_view.iterator();
1067                         while (it.next()) |kv| {
1068                             const name = kv.val.name;
1069                             const post_list = kv.val.list;
1070                             try res.write(
1071                                 \\<a href="/list/{x}">{s}</a><br />
1072                             , .{ post_list.idx.?, name.constSlice() });
1073                         }
1074                     } else {
1075                         try res.write("not logged in", .{});
1076                     }
1077                 } else if (std.mem.eql(u8, req.target, "/post")) {
1078                     if (logged_in) |login| {
1079                         _ = login;
1080                         const referer = if (req.get_header("Referer")) |ref| ref else req.target;
1081
1082                         try html_form(&res, "/post", .{}, .{
1083                             .{ "type=\"hidden\" name=\"referer\" value=\"{s}\"", .{referer} },
1084                             "type=\"text\" name=\"text\"",
1085                             "type=\"submit\" value=\"Post\"",
1086                         });
1087                     } else {
1088                         try res.write("not logged in", .{});
1089                     }
1090                 } else if (std.mem.eql(u8, req.target, "/edit")) {
1091                     if (logged_in) |login| {
1092                         try res.write("<br />Username: ", .{});
1093                         try html_form(&res, "/set_username", .{}, .{
1094                             .{ "type=\"text\" name=\"username\" placeholder=\"{s}\"", .{login.user.name.constSlice()} },
1095                             "type=\"submit\" value=\"Change\"",
1096                         });
1097                         try res.write("<br />Display Name: ", .{});
1098                         try html_form(&res, "/set_display_name", .{}, .{
1099                             .{ "type=\"text\" name=\"display_name\" placeholder=\"{s}\"", .{login.user.display_name.constSlice()} },
1100                             "type=\"submit\" value=\"Change\"",
1101                         });
1102                         try res.write("<br />Password: ", .{});
1103                         try html_form(&res, "/set_password", .{}, .{
1104                             "type=\"text\" name=\"password\"",
1105                             "type=\"submit\" value=\"Change\"",
1106                         });
1107                     } else {
1108                         try res.write("not logged in", .{});
1109                     }
1110                 } else if (std.mem.eql(u8, req.target, "/")) {
1111                     if (logged_in) |login| {
1112                         try write_timeline(&res, txn, logged_in, login.user.following);
1113                     } else {
1114                         // TODO: generic home
1115                         try res.write("Homepage", .{});
1116                     }
1117                 } else {
1118                     try res.redirect("/");
1119                 }
1120                 try write_end(&res);
1121                 try res.send();
1122             }
1123             // api
1124             else {
1125                 if (std.mem.eql(u8, req.target, "/register")) {
1126                     // TODO: handle args not supplied
1127                     const username = req.get_value("username").?;
1128                     const password = req.get_value("password").?;
1129
1130                     std.debug.print("New user: {s} {s}\n", .{ username, password });
1131                     _ = try Chirp.register_user(env, username, password);
1132                 } else if (std.mem.eql(u8, req.target, "/login")) {
1133                     // TODO: handle args not supplied
1134                     const username = req.get_value("username").?;
1135                     const password = req.get_value("password").?;
1136
1137                     std.debug.print("New login: {s} {s}\n", .{ username, password });
1138                     if (Chirp.login_user(env, username, password)) |session_token| {
1139                         res.status = .see_other;
1140                         try res.add_header(
1141                             "Set-Cookie",
1142                             .{ "session_token={x}; HttpOnly", .{session_token} },
1143                         );
1144                     } else |err| {
1145                         std.debug.print("login_user err: {}\n", .{err});
1146                     }
1147                 } else if (std.mem.eql(u8, req.target, "/logout")) {
1148                     if (logged_in) |login| {
1149                         try Chirp.logout_user(env, login.session_token);
1150
1151                         try res.add_header(
1152                             "Set-Cookie",
1153                             .{"session_token=deleted; Expires=Thu, 01 Jan 1970 00:00:00 GMT"},
1154                         );
1155                     }
1156                 } else if (std.mem.eql(u8, req.target, "/set_username")) {
1157                     const login = logged_in orelse return error.NotLoggedIn;
1158                     const username_str = req.get_value("username") orelse return error.NoUsername;
1159                     const username = try Username.fromSlice(username_str);
1160
1161                     const txn = try env.txn();
1162                     defer txn.commit() catch {};
1163
1164                     const user_ids = try Db.user_ids(txn);
1165
1166                     if (!try user_ids.has(username)) {
1167                         try user_ids.del(login.user.name);
1168                         try user_ids.put(username, login.user.id);
1169
1170                         const users = try Db.users(txn);
1171                         var user = login.user;
1172                         user.name = username;
1173                         try users.put(login.user.id, user);
1174                     }
1175                 } else if (std.mem.eql(u8, req.target, "/set_display_name")) {
1176                     const login = logged_in orelse return error.NotLoggedIn;
1177                     const display_name_str = req.get_value("display_name") orelse return error.NoDisplayName;
1178                     const display_name = try DisplayName.fromSlice(display_name_str);
1179
1180                     const txn = try env.txn();
1181                     defer txn.commit() catch {};
1182
1183                     const users = try Db.users(txn);
1184                     var user = login.user;
1185                     user.display_name = display_name;
1186                     try users.put(login.user.id, user);
1187                 } else if (std.mem.eql(u8, req.target, "/set_password")) {
1188                     const login = logged_in orelse return error.NotLoggedIn;
1189                     const password_str = req.get_value("password") orelse return error.NoPassword;
1190
1191                     const txn = try env.txn();
1192                     defer txn.commit() catch {};
1193
1194                     const users = try Db.users(txn);
1195                     var user = login.user;
1196                     user.password_hash = try Chirp.hash_password(password_str);
1197                     try users.put(login.user.id, user);
1198                 } else if (std.mem.eql(u8, req.target, "/post")) {
1199                     if (logged_in) |login| {
1200                         const text = req.get_value("text").?;
1201                         const has_referer = req.get_value("referer");
1202
1203                         try Chirp.post(env, login.user.id, text);
1204
1205                         if (has_referer) |r| {
1206                             const decoded = try decode(r);
1207                             try res.redirect(decoded.constSlice());
1208                         }
1209                     }
1210                 } else if (std.mem.eql(u8, req.target, "/comment")) {
1211                     if (logged_in) |login| {
1212                         const text = req.get_value("text") orelse return error.NoText;
1213                         const post_id_str = req.get_value("post_id") orelse return error.NoPostId;
1214                         const post_id = try parse_enum(PostId, post_id_str, 16);
1215
1216                         try Chirp.comment(env, login.user.id, post_id, text);
1217                     }
1218                 } else if (std.mem.eql(u8, req.target, "/quote")) {
1219                     if (logged_in) |login| {
1220                         const text = req.get_value("text") orelse return error.NoText;
1221                         const post_id_str = req.get_value("post_id") orelse return error.NoPostId;
1222                         const has_referer = req.get_value("referer");
1223
1224                         const post_id = try parse_enum(PostId, post_id_str, 16);
1225
1226                         try Chirp.quote(env, login.user.id, post_id, text);
1227
1228                         if (has_referer) |r| {
1229                             const decoded = try decode(r);
1230                             try res.redirect(decoded.constSlice());
1231                         }
1232                     }
1233                 } else if (std.mem.eql(u8, req.target, "/new_list")) {
1234                     if (logged_in) |login| {
1235                         const name_str = req.get_value("name") orelse return error.NoName;
1236                         const name = try Name.fromSlice(name_str);
1237
1238                         var txn = try env.txn();
1239
1240                         const postlist = try PostList.init(txn);
1241                         try txn.commit();
1242
1243                         txn = try env.txn();
1244                         var post_lists_view = try login.user.post_lists.open(txn);
1245                         _ = try post_lists_view.append(.{ .name = name, .list = postlist });
1246                         try txn.commit();
1247                     }
1248                 } else if (std.mem.eql(u8, req.target, "/list_add")) {
1249                     if (logged_in) |login| {
1250                         _ = login;
1251
1252                         const list_id_str = req.get_value("list_id") orelse return error.NoListId;
1253                         const post_id_str = req.get_value("post_id") orelse return error.NoPostId;
1254                         const list_id = try std.fmt.parseUnsigned(PostList.Index, list_id_str, 16);
1255                         const post_id = try parse_enum(PostId, post_id_str, 16);
1256
1257                         const txn = try env.txn();
1258                         defer txn.commit() catch {};
1259
1260                         const post_list = PostList{ .idx = list_id };
1261                         var post_list_view = try post_list.open(txn);
1262                         std.debug.print("adding {x} to {x}\n", .{ post_id, list_id });
1263                         if (try post_list_view.has(post_id)) {
1264                             try post_list_view.del(post_id);
1265                         } else {
1266                             try post_list_view.append(post_id);
1267                         }
1268                     }
1269                 } else if (std.mem.eql(u8, req.target, "/upvote")) {
1270                     const login = logged_in orelse return error.NotLoggedIn;
1271
1272                     const post_id_str = req.get_value("post_id") orelse return error.NoPostId;
1273                     const post_id: PostId = @enumFromInt(try std.fmt.parseUnsigned(u64, post_id_str, 16));
1274
1275                     try Chirp.vote(env, post_id, login.user.id, .Up);
1276                 } else if (std.mem.eql(u8, req.target, "/downvote")) {
1277                     const login = logged_in orelse return error.NotLoggedIn;
1278
1279                     const post_id_str = req.get_value("post_id") orelse return error.NoPostId;
1280                     const post_id: PostId = @enumFromInt(try std.fmt.parseUnsigned(u64, post_id_str, 16));
1281
1282                     try Chirp.vote(env, post_id, login.user.id, .Down);
1283                 } else if (std.mem.eql(u8, req.target, "/follow")) {
1284                     const login = logged_in orelse return error.NotLoggedIn;
1285
1286                     const user_id_str = req.get_value("user_id") orelse return error.NoUserId;
1287                     const user_id: UserId = @enumFromInt(try std.fmt.parseUnsigned(u64, user_id_str, 16));
1288
1289                     try Chirp.follow(env, login.user.id, user_id);
1290                 } else if (std.mem.eql(u8, req.target, "/quit")) {
1291                     if (req.get_header("Referer")) |ref| {
1292                         try res.redirect(ref);
1293                     } else {
1294                         try res.redirect("/");
1295                     }
1296                     try res.send();
1297                     break :accept;
1298                 } else {
1299                     try res.write("<p>[POST] {s}</p>", .{req.target});
1300                 }
1301
1302                 if (!res.has_header("Location")) {
1303                     if (req.get_header("Referer")) |ref| {
1304                         try res.redirect(ref);
1305                     } else {
1306                         try res.redirect("/");
1307                     }
1308                 }
1309                 try res.send();
1310             }
1311         }
1312     }
1313 }