Sell every seat once.

frappe new boxoffice
cd boxoffice

frappe make domain BoxOffice Seating --means="selling the seats of each show"

# The BoxOffice domain, in SweetTalk (ADRs 0030 and 0031). Its words, such as
# context, value, aggregate, event and whenever, exist only inside this module.
module App::BoxOffice
  include SweetTalk

  context Seating, subdomain: :core, means: "selling the seats of each show" do
    HOLD_FOR = 10.minutes

    value Capacity, Int32, within: 1..5000, means: "the seats a show can sell"
    value Seats, Int32, within: 1..8, means: "the seats one guest takes at one checkout"
    value Email, String, matches: /\A[^@\s]+@[^@\s]+\z/, length: 3..254,
      means: "where we send a guest's tickets"

    aggregate Show, means: "one performance and the seats it sells" do
      has title : String
      has starts_at : Time
      has capacity : Capacity
      has issued : Int32 = 0
      has holds : Array(Hold)
      has tickets : Array(Ticket)
      moves on_sale >> closed
      never "A show cannot sell more seats than it has." { sold + held > capacity.to_i }

      entity Hold, means: "seats kept for one guest while they pay" do
        has number : Int32
        has guest : Email
        has seats : Seats
        has expires_at : Time
      end

      entity Ticket, means: "seats one guest paid for" do
        has number : Int32
        has guest : Email
        has seats : Seats
      end

      the held : Int32 = holds.sum(&.seats.to_i)
      the sold : Int32 = tickets.sum(&.seats.to_i)
      the left : Int32 = capacity.to_i - sold - held

  event Scheduled, means: "a show went on sale"
  event Held, number : Int32, guest : Email, seats : Seats, expires_at : Time,
    means: "seats were kept for a guest until a time"
  event Sold, number : Int32, guest : Email, seats : Seats,
    means: "a guest paid for the seats held for them"
  event Released, number : Int32, seats : Seats, reason : String,
    means: "held seats went back on sale, and why"

  factory schedule(title : String, starts_at : Time, capacity : Capacity) do
    emit Scheduled
  end

  to hold(guest : Email, seats : Seats) do
    refuse "Sales for #{title} have closed." if closed?
    refuse "#{title} is sold out." if left.zero?
    refuse "Only #{left} of #{capacity.to_i} seats left for #{title}." if seats.to_i > left
    @issued += 1
    expires_at = Time.utc + HOLD_FOR
    @holds << Hold.new(@issued, guest, seats, expires_at)
    emit Held, number: @issued, guest: guest, seats: seats, expires_at: expires_at
  end

  to sell(number : Int32) do
    hold = holds.find { |kept| kept.number == number }
    refuse "Hold #{number} is no longer held." unless hold
    @holds.reject! { |kept| kept.number == number }
    @tickets << Ticket.new(number, hold.guest, hold.seats)
    emit Sold, number: number, guest: hold.guest, seats: hold.seats
  end

  to release(number : Int32, reason : String) do
    if hold = holds.find { |kept| kept.number == number }
      @holds.reject! { |kept| kept.number == number }
      emit Released, number: number, seats: hold.seats, reason: reason
    end
  end

  to close do
    closed!
  end
end

value Claim, means: "one hold on one show" do
  part show : Int64
  part number : Int32
end

process Checkout, means: "the time one guest has to pay for the seats held for them" do
  key claim : Claim

  whenever Show::Held,
    key: Claim.new(show: held.show_id.raw, number: held.number) do |held|
    arm lapse, after: held.expires_at - Time.utc
  end

  whenever Show::Sold,
    key: Claim.new(show: sold.show_id.raw, number: sold.number) do |sold|
    disarm lapse
  end

  whenever Show::Released,
    key: Claim.new(show: released.show_id.raw, number: released.number) do |released|
    disarm lapse
  end

  deadline lapse, after: HOLD_FOR do
    Show.find(Show::Id.new(claim.show)).release(claim.number, "not paid in time")
  end
end

  border Waitlist do
    whenever Waitlist::Line::Offered do |offered|
      Show.find(offered.show).hold(offered.email, offered.seats)
    end

    compensate Waitlist::Line::Offered do |offered, refusal|
      # The seats went to someone else first: the guest stays in the line.
    end
  end
end

  context Waitlist, follows: Seating, subdomain: :supporting,
    means: "guests waiting for the seats a show gives back" do
    aggregate Line, means: "the guests waiting for one show, first come, first served" do
      has show : Seating::Show
      has guests : Array(Guest)

      entity Guest, means: "one guest in the line, and the seats they want" do
        has email : Seating::Email
        has seats : Seating::Seats
      end

      event Offered, show : Seating::Show::Id, email : Seating::Email, seats : Seating::Seats,
        means: "seats came free for the first guest in the line they fit"

      finds for_show(show : Seating::Show::Id), where: {show: show}

      to join(email : Seating::Email, seats : Seating::Seats) do
        waiting = guests.any? { |guest| guest.email.raw == email.raw }
        refuse "#{email.raw} is already waiting." if waiting
        @guests << Guest.new(email, seats)
      end

      to offer(free : Int32) do
        if first = guests.find { |guest| guest.seats.to_i <= free }
          emit Offered, show: show, email: first.email, seats: first.seats
        end
      end

      to seat(email : Seating::Email) do
        @guests.reject! { |guest| guest.email.raw == email.raw }
      end
    end

    whenever Seating::Show::Scheduled do |scheduled|
      Line.create(show: scheduled.show_id)
    end

    whenever Seating::Show::Held do |held|
      Line.for_show(held.show_id).first?.try(&.seat(held.guest))
    end

    whenever Seating::Show::Released do |released|
      free = Seating::Show.find(released.show_id).left
      Line.for_show(released.show_id).first?.try(&.offer(free))
    end
  end
end

frappe format
frappe check

frappe db diff --name create_box_office

frappe migrate

module App::Views::Shows
  class Show < App::ApplicationView
    def initialize(@show : BoxOffice::Seating::Show, @csrf_token : String)
    end

    private def blueprint
      section class: "show" do
        h1 { @show.title }
        p { @show.starts_at.to_s("%A %d %B %Y, %H:%M UTC") }
        p { "#{@show.left} of #{@show.capacity.to_i} seats left" }
        if @show.closed?
          p { "Sales for this show have closed." }
        elsif @show.left > 0
          seats_form("holds", "Hold seats")
        else
          seats_form("waitlist", "Join the waitlist")
        end
      end
    end

    private def seats_form(path : String, submit : String) : Nil
      form action: "/shows/#{@show.id.raw}/#{path}", method: "post" do
        input type: "hidden", name: "_csrf", value: @csrf_token
        label(for: "guest") { "Email" }
        input id: "guest", type: "email", name: "guest", required: true
        label(for: "seats") { "Seats" }
        input id: "seats", type: "number", name: "seats", value: "1", required: true
        button(type: "submit") { submit }
      end
    end
  end
end

module App::Views::Holds
  class Show < App::ApplicationView
    def initialize(@show : BoxOffice::Seating::Show, @number : Int32, @csrf_token : String)
    end

    private def blueprint
      section class: "hold" do
        h1 { @show.title }
        if hold = @show.holds.find { |kept| kept.number == @number }
          due = hold.expires_at.to_s("%H:%M")
          p { "#{hold.seats.to_i} seats held for #{hold.guest.raw} until #{due} UTC." }
          form action: "/shows/#{@show.id.raw}/holds/#{@number}/sale", method: "post" do
            input type: "hidden", name: "_csrf", value: @csrf_token
            button(type: "submit") { "Pay for the seats" }
          end
        elsif ticket = @show.tickets.find { |sold| sold.number == @number }
          p { "Paid: #{ticket.seats.to_i} seats. The tickets go to #{ticket.guest.raw}." }
        else
          p { "This hold has ended, and its seats went back on sale." }
          a(href: "/shows/#{@show.id.raw}") { "Back to #{@show.title}" }
        end
      end
    end
  end
end

frappe check

get "/shows/:show", App::Shows::Show
post "/shows/:show/holds", App::Holds::Create
get "/shows/:show/holds/:hold", App::Holds::Show
post "/shows/:show/holds/:hold/sale", App::Holds::Sell
post "/shows/:show/waitlist", App::Waitlists::Join

module App::Shows
  struct Show < App::ApplicationAction
    contract do
      field show : BoxOffice::Seating::Show::Id
    end

    def handle(contract : Contract)
      show = BoxOffice::Seating::Show.find(contract.show)
      page show.title, Views::Shows::Show.new(show, csrf_token)
    end
  end
end

module App::Holds
  struct Create < App::ApplicationAction
    contract do
      field show : BoxOffice::Seating::Show::Id
      field guest : BoxOffice::Seating::Email
      field seats : BoxOffice::Seating::Seats
    end

    def handle(contract : Contract)
      show = BoxOffice::Seating::Show.find(contract.show)
      show.hold(contract.guest, contract.seats)
      redirect_to("/shows/#{show.id.raw}/holds/#{show.issued}")
    end
  end
end

module App::Holds
  struct Show < App::ApplicationAction
    contract do
      field show : BoxOffice::Seating::Show::Id
      field hold : Int32, min: 1
    end

    def handle(contract : Contract)
      show = BoxOffice::Seating::Show.find(contract.show)
      page "Your seats", Views::Holds::Show.new(show, contract.hold, csrf_token)
    end
  end
end

module App::Holds
  struct Sell < App::ApplicationAction
    contract do
      field show : BoxOffice::Seating::Show::Id
      field hold : Int32, min: 1
    end

    def handle(contract : Contract)
      BoxOffice::Seating::Show.find(contract.show).sell(contract.hold)
      redirect_to("/shows/#{contract.show.raw}/holds/#{contract.hold}")
    end
  end
end

module App::Waitlists
  struct Join < App::ApplicationAction
    contract do
      field show : BoxOffice::Seating::Show::Id
      field guest : BoxOffice::Seating::Email
      field seats : BoxOffice::Seating::Seats
    end

    def handle(contract : Contract)
      line = BoxOffice::Waitlist::Line.for_show(contract.show).first?
      return not_found unless line
      line.join(contract.guest, contract.seats)
      redirect_to("/shows/#{contract.show.raw}")
    end
  end
end

frappe routes shows

module App
  # Schedules one show the first time it runs; a second run finds it and does nothing.
  def self.seed(db : DB::Database) : Nil
    return unless BoxOffice::Seating::Show.all.empty?

    BoxOffice::Seating::Show.schedule("The Tempest", Time.utc + 30.days,
      BoxOffice::Seating::Capacity.new(120))
    puts "Scheduled The Tempest with 120 seats."
  end
end

frappe seed

frappe dev

# Builders and readers that the box office's specs share.
module BoxOfficeSpec
  extend self

  def show(capacity : Int32) : App::BoxOffice::Seating::Show
    App::BoxOffice::Seating::Show.schedule("The Tempest", Time.utc(2026, 11, 20, 19, 30),
      App::BoxOffice::Seating::Capacity.new(capacity))
  end

  def email(text : String) : App::BoxOffice::Seating::Email
    App::BoxOffice::Seating::Email.new(text)
  end

  def seats(count : Int32) : App::BoxOffice::Seating::Seats
    App::BoxOffice::Seating::Seats.new(count)
  end

  def reload(show : App::BoxOffice::Seating::Show) : App::BoxOffice::Seating::Show
    App::BoxOffice::Seating::Show.find(show.id)
  end

  def line(show : App::BoxOffice::Seating::Show) : App::BoxOffice::Waitlist::Line
    App::BoxOffice::Waitlist::Line.for_show(show.id).first
  end
end

require "../spec_helper"
require "../support/box_office"

describe App::BoxOffice do
  it "refuses a hold for more seats than are left" do
    Corretto.session do |_client, _db|
      show = BoxOfficeSpec.show(3)
      show.hold(BoxOfficeSpec.email("ada@example.com"), BoxOfficeSpec.seats(2))
      expect_raises(SweetTalk::Refusal, "Only 1 of 3 seats left for The Tempest.") do
        show.hold(BoxOfficeSpec.email("bo@example.com"), BoxOfficeSpec.seats(2))
      end
      BoxOfficeSpec.reload(show).left.should eq(1)
    end
  end

  it "refuses a hold once sales have closed" do
    Corretto.session do |_client, _db|
      show = BoxOfficeSpec.show(2)
      show.close
      expect_raises(SweetTalk::Refusal, "Sales for The Tempest have closed.") do
        show.hold(BoxOfficeSpec.email("ada@example.com"), BoxOfficeSpec.seats(1))
      end
    end
  end

  it "releases unpaid seats when the ten minutes run out" do
    Corretto.session do |_client, db|
      show = BoxOfficeSpec.show(2)
      show.hold(BoxOfficeSpec.email("ada@example.com"), BoxOfficeSpec.seats(2))
      Caramel::ColdBrew.drain_queue!(db)
      due = db.query_one("SELECT run_at FROM caramel_jobs WHERE class_name = $1",
        "App::BoxOffice::Seating::Checkout::LapseDeadline", as: Time)
      (due - Time.utc - 10.minutes).abs.should be < 1.minute
      Caramel::ColdBrew.drain_queue!(db, include_scheduled: true)
      BoxOfficeSpec.reload(show).left.should eq(2)
    end
  end

  it "keeps paid seats when the timer runs out after payment" do
    Corretto.session do |_client, db|
      show = BoxOfficeSpec.show(2)
      show.hold(BoxOfficeSpec.email("ada@example.com"), BoxOfficeSpec.seats(2))
      Caramel::ColdBrew.drain_queue!(db)
      show.sell(1)
      Caramel::ColdBrew.drain_queue!(db, include_scheduled: true)
      sold = BoxOfficeSpec.reload(show)
      sold.tickets.map(&.guest.raw).should eq(["ada@example.com"])
      sold.left.should eq(0)
    end
  end

  it "offers released seats to the first guest in the line they fit" do
    Corretto.session do |_client, db|
      show = BoxOfficeSpec.show(2)
      Caramel::ColdBrew.drain_queue!(db)
      show.hold(BoxOfficeSpec.email("ada@example.com"), BoxOfficeSpec.seats(2))
      line = BoxOfficeSpec.line(show)
      line.join(BoxOfficeSpec.email("cy@example.com"), BoxOfficeSpec.seats(3))
      line.join(BoxOfficeSpec.email("di@example.com"), BoxOfficeSpec.seats(2))
      show.release(1, "changed plans")
      Caramel::ColdBrew.drain_queue!(db)
      BoxOfficeSpec.reload(show).holds.map(&.guest.raw).should eq(["di@example.com"])
      BoxOfficeSpec.line(show).guests.map(&.email.raw).should eq(["cy@example.com"])
    end
  end
end

require "../spec_helper"
require "../support/box_office"

describe "The box office" do
  it "holds seats, sells them, and offers the waitlist once the show is sold out" do
    Corretto.session do |client, db|
      show = BoxOfficeSpec.show(2)
      Caramel::ColdBrew.drain_queue!(db)
      path = "/shows/#{show.id.raw}"
      client.get(path).should have_html {
        section(class: "show") { button(type: "submit") { "Hold seats" } }
      }
      held = client.post("#{path}/holds", params: {"guest" => "ada@example.com", "seats" => "2"})
      held.should redirect_to("#{path}/holds/1")
      client.follow_redirect.should have_html {
        section(class: "hold") { button(type: "submit") { "Pay for the seats" } }
      }
      client.get(path).should have_html {
        section(class: "show") { button(type: "submit") { "Join the waitlist" } }
      }
      joined = client.post("#{path}/waitlist",
        params: {"guest" => "bo@example.com", "seats" => "1"})
      joined.should redirect_to(path)
      BoxOfficeSpec.line(show).guests.map(&.email.raw).should eq(["bo@example.com"])
      client.post("#{path}/holds/1/sale").should redirect_to("#{path}/holds/1")
      client.follow_redirect.should have_html {
        section(class: "hold") { p { "Paid: 2 seats. The tickets go to ada@example.com." } }
      }
    end
  end

  it "answers 422 for a refusal or a bad value, and 404 for a show that is not a number" do
    Corretto.session do |client, _db|
      show = BoxOfficeSpec.show(1)
      show.hold(BoxOfficeSpec.email("ada@example.com"), BoxOfficeSpec.seats(1))
      path = "/shows/#{show.id.raw}/holds"
      json = {"Accept" => "application/json"}
      sold_out = client.post(path, headers: json,
        params: {"guest" => "bo@example.com", "seats" => "1"})
      sold_out.should have_status(422)
      sold_out.body.should eq(%({"errors":{"_base":["The Tempest is sold out."]}}))
      too_many = client.post(path, headers: json,
        params: {"guest" => "bo@example.com", "seats" => "9"})
      too_many.should have_status(422)
      too_many.body.should eq(%({"errors":{"seats":["Seats must be between 1 and 8"]}}))
      stray = client.post("/shows/abc/holds",
        params: {"guest" => "bo@example.com", "seats" => "1"})
      stray.should have_status(404)
    end
  end

  it "offers a closed show nothing" do
    Corretto.session do |client, _db|
      show = BoxOfficeSpec.show(2)
      show.close
      client.get("/shows/#{show.id.raw}").should have_html {
        section(class: "show") { p { "Sales for this show have closed." } }
      }
    end
  end
end

frappe corretto