Version 3 (#67)

Bump yargs-parser from 5.0.0 to 5.0.1 in /src/app

.gitignore

@@ -252,8 +252,5 @@ paket-files/
 .idea/
 *.sln.iml
 
-# Compiled files / application
+# Ionide VSCode extension
-src/api/public/index.html
+.ionide
-src/api/public/static
-src/api/appsettings.json
-build/

README.md

@@ -4,8 +4,8 @@
 
 Journaling has a long history; it helps people remember what happened, and the act of writing helps people think about what happened and process it. A prayer journal is not a new concept; it helps you keep track of the requests for which you've prayed, you can use it to pray over things repeatedly, and you can write the result when the answer comes _(or it was "no")_.
 
-myPrayerJournal was borne of out of a personal desire I (Daniel) had to have something that would help me with my prayer life. When it's time to pray, it's not really time to use an app, so the design goal here is to keep it simple and unobtrusive. It will also help eliminate some of the downsides to a paper prayer journal, like not remembering whether you've prayed for a request, or running out of room to write another update on one.
+myPrayerJournal was borne of out of a personal desire [Daniel](https://github.com/danieljsummers) had to have something that would help him with his prayer life. When it's time to pray, it's not really time to use an app, so the design goal here is to keep it simple and unobtrusive. It will also help eliminate some of the downsides to a paper prayer journal, like not remembering whether you've prayed for a request, or running out of room to write another update on one.
 
 ## Futher Reading
 
-The documentation for the site is at <https://danieljsummers.github.io/myPrayerJournal/>.
+The documentation for the site is at <https://bit-badger.github.io/myPrayerJournal/>.

docs/CNAME

@@ -0,0 +1 @@
+docs.prayerjournal.me

docs/index.md

@@ -4,7 +4,7 @@
 
 Journaling has a long history; it helps people remember what happened, and the act of writing helps people think about what happened and process it. A prayer journal is not a new concept; it helps you keep track of the requests for which you've prayed, you can use it to pray over things repeatedly, and you can write the result when the answer comes _(or it was "no")_.
 
-myPrayerJournal was borne of out of a personal desire I (Daniel) had to have something that would help me with my prayer life. When it's time to pray, it's not really time to use an app, so the design goal here is to keep it simple and unobtrusive. It will also help eliminate some of the downsides to a paper prayer journal, like not remembering whether you've prayed for a request, or running out of room to write another update on one.
+myPrayerJournal was borne of out of a personal desire [Daniel](https://github.com/danieljsummers) had to have something that would help him with his prayer life. When it's time to pray, it's not really time to use an app, so the design goal here is to keep it simple and unobtrusive. It will also help eliminate some of the downsides to a paper prayer journal, like not remembering whether you've prayed for a request, or running out of room to write another update on one.
 
 ## Finding the Site
 
@@ -16,15 +16,19 @@ myPrayerJournal uses login services using Google or Microsoft accounts. The only
 
 ## Your Prayer Journal
 
-Your current requests will be presented in three columns (or two or one, depending on the size of your screen or device). Each request is in its own card, and the buttons at the top of each card apply to that request. The last line of each request also tells you how long it has been since anything has been done on that request. Any time you see something like "a few minutes ago," you can hover over that to see the actual date/time the action was taken.
+Your current requests will be presented in columns (usually three, but it could be more or less, depending on the size of your screen or device). Each request is in its own card, and the buttons at the top of each card apply to that request. The last line of each request also tells you how long it has been since anything has been done on that request. Any time you see something like "a few minutes ago," you can hover over that to see the actual date/time the action was taken.
 
 ## Adding a Request
 
 To add a request, click the "Add a New Request" button at the top of your journal. Then, enter the text of the request as you see fit; there is no right or wrong way, and you are the only person who will see the text you enter. When you save the request, it will go to the bottom of the list of requests.
 
+## Setting Request Recurrence
+
+When you add or update a request, you can choose whether requests go to the bottom of the journal once they have been marked "Prayed" or whether they will reappear after a delay. You can set recurrence in terms of hours, days, or weeks, but it cannot be longer than 365 days. If you decide you want a request to reappear sooner, you can skip the current delay; click the "Active" menu link, find the request in the list (likely near the bottom), and click the "Show Now" button.
+
 ## Praying for Requests
 
-The first button for each request has a checkmark icon; clicking this button will mark the request as "Prayed" and move it to the bottom of the list. This allows you, if you're praying through your requests, to start at the top left (with the request that it's been the longest since you've prayed) and click the button as you pray; when the request goes to the bottom of the list, the next-least-recently-prayed request will take the top spot.
+The first button for each request has a checkmark icon; clicking this button will mark the request as "Prayed" and move it to the bottom of the list (or off, if you've set a recurrence period for the request). This allows you, if you're praying through your requests, to start at the top left (with the request that it's been the longest since you've prayed) and click the button as you pray; when the request move below or away, the next-least-recently-prayed request will take the top spot.
 
 ## Editing Requests
 
@@ -32,18 +36,20 @@ The second button for each request has a pencil icon. This allows you to edit th
 
 ## Adding Notes
 
-The third button for each request has an icon that looks like a piece of paper with writing; this lets you record notes about the request. If there is something you want to record that doesn't change the text of the request, this is the place to do it. For example, you may be praying for a long-term health issue, and that person tells you that their status is the same; or, you may want to record something God said to you while you were praying for that request.
+The third button for each request has an icon that looks like a speech bubble with lines on it; this lets you record notes about the request. If there is something you want to record that doesn't change the text of the request, this is the place to do it. For example, you may be praying for a long-term health issue, and that person tells you that their status is the same; or, you may want to record something God said to you while you were praying for that request.
+
+## Snoozing Requests
+
+There may be a time where a request does not need to appear. The fourth button, with the clock icon, allows you to snooze requests until the day you specify. Additionally, if you have any snoozed requests, a "Snoozed" menu item will appear next to the "Journal" one; this page allows you to see what requests are snoozed, and return them to your journal by canceling the snooze.
 
 ## Viewing a Request and Its History
 
-myPrayerJournal tracks all of the actions related to a request; the fourth button, with the magnifying glass icon, will show you the entire history, including the text as it changed, and all the times "Prayed" was recorded.
+myPrayerJournal tracks all of the actions related to a request; from the "Active" and "Answered" menu links (and "Snoozed", if it's showing), there is a "View Full Request" button. That page will show the current text of the request; how many times it has been marked as prayed; how long it has been an active request; and a log of all updates, prayers, and notes you have recorded. That log is listed from most recent to least recent; if you want to read it chronologically, just press the "End" key on your keyboard and read it from the bottom up.
 
-## Answered Requests
+The "Active" link will show all requests that have not yet been marked answered, including snoozed and recurring requests. If requests are snoozed, or in a recurrence period off the journal, there will be a button where you can return the request to the list (either "Cancel Snooze" or "Show Now"). The "Answered" link shows all requests that have been marked answered. The "Snoozed" link just shows snoozed requests.
-
-Next to "Journal" on the top navigation is the word "Answered." This page lists all answered requests, from most recent to least recent, along with the text of the request at the time it was marked as answered. It will also show you when it was marked answered. The button at the bottom of each request, with the magnifying glass and the words "Show Full Request", link to a page that shows that request's complete history and notes, along with a few statistics about that request. The history and notes are listed from most recent to least recent; if you want to read it chronologically, just press the "End" key on your keyboard and read it from the bottom up.
 
 ## Final Notes
 
-- myPrayerJournal is currently in public beta. If you encounter errors, please [file an issue on GitHub](https://github.com/danieljsummers/myPrayerJournal/issues) with as much detail as possible. You can also browse the list of issues to see what has been done and what is still left to do.
+- If you encounter errors, please [file an issue on GitHub](https://github.com/bit-badger/myPrayerJournal/issues) with as much detail as possible. You can also provide suggestions, or browse the list of currently open issues.
 - Prayer requests and their history are securely backed up nightly along with other Bit Badger Solutions data.
 - Prayer changes things - most of all, the one doing the praying. I pray that this tool enables you to deepen and strengthen your prayer life.

publish.ps1

@@ -0,0 +1,3 @@
+#!/snap/bin/pwsh
+Set-Location src/MyPrayerJournal
+dotnet publish -c Release -r linux-x64 -p:PublishSingleFile=true --self-contained false

src/MyPrayerJournal.Migrate/Migrate.fsproj

@@ -0,0 +1,22 @@
+<Project Sdk="Microsoft.NET.Sdk">
+
+  <PropertyGroup>
+    <OutputType>Exe</OutputType>
+    <TargetFramework>net6.0</TargetFramework>
+  </PropertyGroup>
+
+  <ItemGroup>
+    <Compile Include="Program.fs" />
+  </ItemGroup>
+
+  <ItemGroup>
+    <PackageReference Include="FSharp.Data" Version="4.2.3" />
+    <PackageReference Include="LiteDB" Version="5.0.11" />
+    <PackageReference Include="NodaTime" Version="3.0.9" />
+  </ItemGroup>
+
+  <ItemGroup>
+    <ProjectReference Include="..\MyPrayerJournal\MyPrayerJournal.fsproj" />
+  </ItemGroup>
+
+</Project>

src/MyPrayerJournal.Migrate/Program.fs

@@ -0,0 +1,57 @@
+open FSharp.Data
+open FSharp.Data.CsvExtensions
+open LiteDB
+open MyPrayerJournal.Domain
+open NodaTime
+
+module Subdocs =
+  
+  open FSharp.Data.JsonExtensions
+
+  let history json =
+    match JsonValue.Parse json with
+    | JsonValue.Array hist ->
+      hist
+      |> Array.map (fun h ->
+          { asOf   = (h?asOf.AsInteger64 >> Instant.FromUnixTimeMilliseconds) ()
+            status = h?status.AsString () |> RequestAction.ofString
+            text   = match h?text.AsString () with "" -> None | txt -> Some txt
+            })
+      |> List.ofArray
+    | _ -> []
+  
+  let notes json =
+    match JsonValue.Parse json with
+    | JsonValue.Array notes ->
+        notes
+        |> Array.map (fun n ->
+            { asOf = (n?asOf.AsInteger64 >> Instant.FromUnixTimeMilliseconds) ()
+              notes = n?notes.AsString ()
+              })
+        |> List.ofArray
+    | _ -> []
+
+let oldData = CsvFile.Load("data.csv")
+
+let db = new LiteDatabase("Filename=./mpj.db")
+
+MyPrayerJournal.Data.Startup.ensureDb db
+
+let migrated =
+  oldData.Rows
+  |> Seq.map (fun r ->
+      { id           = r["@id"].Replace ("Requests/", "") |> RequestId.ofString
+        enteredOn    = (r?enteredOn.AsInteger64 >> Instant.FromUnixTimeMilliseconds) ()
+        userId       = UserId r?userId
+        snoozedUntil = (r?snoozedUntil.AsInteger64 >> Instant.FromUnixTimeMilliseconds) ()
+        showAfter    = (r?showAfter.AsInteger64 >> Instant.FromUnixTimeMilliseconds) ()
+        recurType    = r?recurType |> Recurrence.ofString
+        recurCount   = (r?recurCount.AsInteger >> int16) ()
+        history      = Subdocs.history r?history
+        notes        = Subdocs.notes r?notes
+      })
+  |> db.GetCollection<Request>("request").Insert
+
+db.Checkpoint ()
+
+printfn $"Migrated {migrated} requests"

src/MyPrayerJournal/.gitignore

@@ -0,0 +1,5 @@
+## LiteDB database file
+*.db
+
+## Development settings
+appsettings.Development.json

src/MyPrayerJournal/Data.fs

@@ -0,0 +1,209 @@
+module MyPrayerJournal.Data
+
+open LiteDB
+open NodaTime
+open System
+open System.Threading.Tasks
+
+// fsharplint:disable MemberNames
+
+/// LiteDB extensions
+[<AutoOpen>]
+module Extensions =
+  
+  /// Extensions on the LiteDatabase class
+  type LiteDatabase with
+    /// The Request collection
+    member this.requests
+      with get () = this.GetCollection<Request> "request"
+    /// Async version of the checkpoint command (flushes log)
+    member this.saveChanges () =
+      this.Checkpoint ()
+      Task.CompletedTask
+
+
+/// Map domain to LiteDB
+//  It does mapping, but since we're so DU-heavy, this gives us control over the JSON representation
+[<RequireQualifiedAccess>]
+module Mapping =
+  
+  /// Map a history entry to BSON
+  let historyToBson (hist : History) : BsonValue =
+    let doc = BsonDocument ()
+    doc["asOf"]   <- hist.asOf.ToUnixTimeMilliseconds ()
+    doc["status"] <- RequestAction.toString hist.status
+    doc["text"]   <- match hist.text with Some t -> t | None -> ""
+    upcast doc
+
+  /// Map a BSON document to a history entry
+  let historyFromBson (doc : BsonValue) =
+    { asOf   = Instant.FromUnixTimeMilliseconds doc["asOf"].AsInt64
+      status = RequestAction.ofString doc["status"].AsString
+      text   = match doc["text"].AsString with "" -> None | txt -> Some txt
+      }
+
+  /// Map a note entry to BSON
+  let noteToBson (note : Note) : BsonValue =
+    let doc = BsonDocument ()
+    doc["asOf"]  <- note.asOf.ToUnixTimeMilliseconds ()
+    doc["notes"] <- note.notes
+    upcast doc
+
+  /// Map a BSON document to a note entry
+  let noteFromBson (doc : BsonValue) =
+    { asOf  = Instant.FromUnixTimeMilliseconds doc["asOf"].AsInt64
+      notes = doc["notes"].AsString
+      }
+
+  /// Map a request to its BSON representation
+  let requestToBson req : BsonValue =
+    let doc = BsonDocument ()
+    doc["_id"]          <- RequestId.toString req.id
+    doc["enteredOn"]    <- req.enteredOn.ToUnixTimeMilliseconds ()
+    doc["userId"]       <- UserId.toString req.userId
+    doc["snoozedUntil"] <- req.snoozedUntil.ToUnixTimeMilliseconds ()
+    doc["showAfter"]    <- req.showAfter.ToUnixTimeMilliseconds ()
+    doc["recurType"]    <- Recurrence.toString req.recurType
+    doc["recurCount"]   <- BsonValue req.recurCount
+    doc["history"]      <- BsonArray (req.history |> List.map historyToBson |> Seq.ofList)
+    doc["notes"]        <- BsonArray (req.notes   |> List.map noteToBson    |> Seq.ofList)
+    upcast doc
+  
+  /// Map a BSON document to a request
+  let requestFromBson (doc : BsonValue) =
+    { id           = RequestId.ofString doc["_id"].AsString
+      enteredOn    = Instant.FromUnixTimeMilliseconds doc["enteredOn"].AsInt64
+      userId       = UserId doc["userId"].AsString
+      snoozedUntil = Instant.FromUnixTimeMilliseconds doc["snoozedUntil"].AsInt64
+      showAfter    = Instant.FromUnixTimeMilliseconds doc["showAfter"].AsInt64
+      recurType    = Recurrence.ofString doc["recurType"].AsString
+      recurCount   = int16 doc["recurCount"].AsInt32
+      history      = doc["history"].AsArray |> Seq.map historyFromBson |> List.ofSeq
+      notes        = doc["notes"].AsArray   |> Seq.map noteFromBson    |> List.ofSeq
+      }
+  
+  /// Set up the mapping
+  let register () = 
+    BsonMapper.Global.RegisterType<Request>(
+      Func<Request, BsonValue> requestToBson, Func<BsonValue, Request> requestFromBson)
+
+/// Code to be run at startup
+module Startup =
+  
+  /// Ensure the database is set up
+  let ensureDb (db : LiteDatabase) =
+    db.requests.EnsureIndex (fun it -> it.userId) |> ignore
+    Mapping.register ()
+
+
+/// Async wrappers for LiteDB, and request -> journal mappings
+[<AutoOpen>]
+module private Helpers =
+
+  open System.Linq
+
+  /// Convert a sequence to a list asynchronously (used for LiteDB IO)
+  let toListAsync<'T> (q : 'T seq) =
+    (q.ToList >> Task.FromResult) ()
+
+  /// Convert a sequence to a list asynchronously (used for LiteDB IO)
+  let firstAsync<'T> (q : 'T seq) =
+    q.FirstOrDefault () |> Task.FromResult
+
+  /// Async wrapper around a request update
+  let doUpdate (db : LiteDatabase) (req : Request) =
+    db.requests.Update req |> ignore
+    Task.CompletedTask
+
+
+/// Retrieve a request, including its history and notes, by its ID and user ID
+let tryFullRequestById reqId userId (db : LiteDatabase) = backgroundTask {
+  let! req = db.requests.Find (Query.EQ ("_id", RequestId.toString reqId)) |> firstAsync
+  return match box req with null -> None | _ when req.userId = userId -> Some req | _ -> None
+  }
+
+/// Add a history entry
+let addHistory reqId userId hist db = backgroundTask {
+  match! tryFullRequestById reqId userId db with
+  | Some req -> do! doUpdate db { req with history = hist :: req.history }
+  | None     -> invalidOp $"{RequestId.toString reqId} not found"
+  }
+
+/// Add a note
+let addNote reqId userId note db = backgroundTask {
+  match! tryFullRequestById reqId userId db with
+  | Some req -> do! doUpdate db { req with notes = note :: req.notes }
+  | None     -> invalidOp $"{RequestId.toString reqId} not found"
+  }
+
+/// Add a request
+let addRequest (req : Request) (db : LiteDatabase) =
+  db.requests.Insert req |> ignore
+
+// FIXME: make a common function here
+
+/// Retrieve all answered requests for the given user
+let answeredRequests userId (db : LiteDatabase) = backgroundTask {
+  let! reqs = db.requests.Find (Query.EQ ("userId", UserId.toString userId)) |> toListAsync
+  return
+    reqs
+    |> Seq.map JournalRequest.ofRequestFull
+    |> Seq.filter (fun it -> it.lastStatus = Answered)
+    |> Seq.sortByDescending (fun it -> it.asOf)
+    |> List.ofSeq
+  }
+
+/// Retrieve the user's current journal
+let journalByUserId userId (db : LiteDatabase) = backgroundTask {
+  let! jrnl = db.requests.Find (Query.EQ ("userId", UserId.toString userId)) |> toListAsync
+  return
+    jrnl
+    |> Seq.map JournalRequest.ofRequestLite
+    |> Seq.filter (fun it -> it.lastStatus <> Answered)
+    |> Seq.sortBy (fun it -> it.asOf)
+    |> List.ofSeq
+  }
+
+/// Does the user have any snoozed requests?
+let hasSnoozed userId now (db : LiteDatabase) = backgroundTask {
+  let! jrnl = journalByUserId userId db
+  return jrnl |> List.exists (fun r -> r.snoozedUntil > now)
+  }
+
+/// Retrieve a request by its ID and user ID (without notes and history)
+let tryRequestById reqId userId db = backgroundTask {
+  let! req = tryFullRequestById reqId userId db
+  return req |> Option.map (fun r -> { r with history = []; notes = [] })
+  }
+
+/// Retrieve notes for a request by its ID and user ID
+let notesById reqId userId (db : LiteDatabase) = backgroundTask {
+  match! tryFullRequestById reqId userId db with | Some req -> return req.notes | None -> return []
+  }
+    
+/// Retrieve a journal request by its ID and user ID
+let tryJournalById reqId userId (db : LiteDatabase) = backgroundTask {
+  let! req = tryFullRequestById reqId userId db
+  return req |> Option.map JournalRequest.ofRequestLite
+  }
+    
+/// Update the recurrence for a request
+let updateRecurrence reqId userId recurType recurCount db = backgroundTask {
+  match! tryFullRequestById reqId userId db with
+  | Some req -> do! doUpdate db { req with recurType = recurType; recurCount = recurCount }
+  | None     -> invalidOp $"{RequestId.toString reqId} not found"
+  }
+
+/// Update a snoozed request
+let updateSnoozed reqId userId until db = backgroundTask {
+  match! tryFullRequestById reqId userId db with
+  | Some req -> do! doUpdate db { req with snoozedUntil = until; showAfter = until }
+  | None     -> invalidOp $"{RequestId.toString reqId} not found"
+  }
+
+/// Update the "show after" timestamp for a request
+let updateShowAfter reqId userId showAfter db = backgroundTask {
+  match! tryFullRequestById reqId userId db with
+  | Some req -> do! doUpdate db { req with showAfter = showAfter }
+  | None     -> invalidOp $"{RequestId.toString reqId} not found"
+  }

src/MyPrayerJournal/Dates.fs

@@ -0,0 +1,78 @@
+/// Date formatting helpers
+//  Many thanks to date-fns (https://date-fns.org) for this logic
+module MyPrayerJournal.Dates
+
+open NodaTime
+
+type internal FormatDistanceToken =
+  | LessThanXMinutes
+  | XMinutes
+  | AboutXHours
+  | XHours
+  | XDays
+  | AboutXWeeks
+  | XWeeks
+  | AboutXMonths
+  | XMonths
+  | AboutXYears
+  | XYears
+  | OverXYears
+  | AlmostXYears
+
+let internal locales =
+  let format = PrintfFormat<int -> string, unit, string, string>
+  Map.ofList [
+    "en-US", Map.ofList [
+      LessThanXMinutes, ("less than a minute", format "less than %i minutes")
+      XMinutes,         ("a minute",           format "%i minutes")
+      AboutXHours,      ("about an hour",      format "about %i hours")
+      XHours,           ("an hour",            format "%i hours")
+      XDays,            ("a day",              format "%i days")
+      AboutXWeeks,      ("about a week",       format "about %i weeks")
+      XWeeks,           ("a week",             format "%i weeks")
+      AboutXMonths,     ("about a month",      format "about %i months")
+      XMonths,          ("a month",            format "%i months")
+      AboutXYears,      ("about a year",       format "about %i years")
+      XYears,           ("a year",             format "%i years")
+      OverXYears,       ("over a year",        format "over %i years")
+      AlmostXYears,     ("almost a year",      format "almost %i years")
+    ]
+  ]
+
+let aDay        =  1_440.
+let almost2Days =  2_520.
+let aMonth      = 43_200.
+let twoMonths   = 86_400.
+
+open System
+
+/// Convert from a JavaScript "ticks" value to a date/time
+let fromJs ticks = DateTime.UnixEpoch + TimeSpan.FromTicks (ticks * 10_000L)
+
+let formatDistance (startDate : Instant) (endDate : Instant) =
+  let format (token, number) locale =
+    let labels = locales |> Map.find locale
+    match number with 1 -> fst labels[token] | _ -> sprintf (snd labels[token]) number
+  let round (it : float) = Math.Round it |> int
+
+  let diff        = startDate - endDate
+  let minutes     = Math.Abs diff.TotalMinutes
+  let formatToken =
+    let months = minutes / aMonth |> round
+    let years  = months / 12
+    match true with
+    | _ when minutes < 1.          -> LessThanXMinutes, 1
+    | _ when minutes < 45.         -> XMinutes, round minutes
+    | _ when minutes < 90.         -> AboutXHours, 1
+    | _ when minutes < aDay        -> AboutXHours, round (minutes / 60.)
+    | _ when minutes < almost2Days -> XDays, 1
+    | _ when minutes < aMonth      -> XDays, round (minutes / aDay)
+    | _ when minutes < twoMonths   -> AboutXMonths, round (minutes / aMonth)
+    | _ when months      < 12      -> XMonths, round (minutes / aMonth)
+    | _ when months % 12 < 3       -> AboutXYears, years
+    | _ when months % 12 < 9       -> OverXYears, years
+    | _                            -> AlmostXYears, years + 1
+  
+  format formatToken "en-US"
+  |> match startDate > endDate with true -> sprintf "%s ago" | false -> sprintf "in %s"
+

src/MyPrayerJournal/Domain.fs

@@ -0,0 +1,213 @@
+[<AutoOpen>]
+/// The data model for myPrayerJournal
+module MyPrayerJournal.Domain
+
+// fsharplint:disable RecordFieldNames
+
+open Cuid
+open NodaTime
+
+/// An identifier for a request
+type RequestId =
+  | RequestId of Cuid
+
+/// Functions to manipulate request IDs
+module RequestId =
+  /// The string representation of the request ID
+  let toString = function RequestId x -> Cuid.toString x
+  /// Create a request ID from a string representation
+  let ofString = Cuid >> RequestId
+
+
+/// The identifier of a user (the "sub" part of the JWT)
+type UserId =
+  | UserId of string
+
+/// Functions to manipulate user IDs
+module UserId =
+  /// The string representation of the user ID
+  let toString = function UserId x -> x
+
+
+/// How frequently a request should reappear after it is marked "Prayed"
+type Recurrence =
+  | Immediate
+  | Hours
+  | Days
+  | Weeks
+
+/// Functions to manipulate recurrences
+module Recurrence =
+  /// Create a string representation of a recurrence
+  let toString =
+    function
+    | Immediate -> "Immediate"
+    | Hours     -> "Hours"
+    | Days      -> "Days"
+    | Weeks     -> "Weeks"
+  /// Create a recurrence value from a string
+  let ofString =
+    function
+    | "Immediate" -> Immediate
+    | "Hours"     -> Hours
+    | "Days"      -> Days
+    | "Weeks"     -> Weeks
+    | it          -> invalidOp $"{it} is not a valid recurrence"
+  /// An hour's worth of seconds
+  let private oneHour = 3_600L
+  /// The duration of the recurrence (in milliseconds)
+  let duration x =
+    (match x with
+    | Immediate -> 0L
+    | Hours     -> oneHour
+    | Days      -> oneHour * 24L
+    | Weeks     -> oneHour * 24L * 7L)
+
+
+/// The action taken on a request as part of a history entry
+type RequestAction =
+  | Created
+  | Prayed
+  | Updated
+  | Answered
+
+
+/// History is a record of action taken on a prayer request, including updates to its text
+[<CLIMutable; NoComparison; NoEquality>]
+type History = {
+  /// The time when this history entry was made
+  asOf   : Instant
+  /// The status for this history entry
+  status : RequestAction
+  /// The text of the update, if applicable
+  text   : string option
+  }
+
+/// Note is a note regarding a prayer request that does not result in an update to its text
+[<CLIMutable; NoComparison; NoEquality>]
+type Note = {
+  /// The time when this note was made
+  asOf  : Instant
+  /// The text of the notes
+  notes : string
+  }
+
+/// Request is the identifying record for a prayer request
+[<CLIMutable; NoComparison; NoEquality>]
+type Request = {
+  /// The ID of the request
+  id           : RequestId
+  /// The time this request was initially entered
+  enteredOn    : Instant
+  /// The ID of the user to whom this request belongs ("sub" from the JWT)
+  userId       : UserId
+  /// The time at which this request should reappear in the user's journal by manual user choice
+  snoozedUntil : Instant
+  /// The time at which this request should reappear in the user's journal by recurrence
+  showAfter    : Instant
+  /// The type of recurrence for this request
+  recurType    : Recurrence
+  /// How many of the recurrence intervals should occur between appearances in the journal
+  recurCount   : int16
+  /// The history entries for this request
+  history      : History list
+  /// The notes for this request
+  notes        : Note list
+  }
+with
+  /// An empty request
+  static member empty =
+    { id           = Cuid.generate () |> RequestId
+      enteredOn    = Instant.MinValue
+      userId       = UserId ""
+      snoozedUntil = Instant.MinValue
+      showAfter    = Instant.MinValue
+      recurType    = Immediate
+      recurCount   = 0s
+      history      = []
+      notes        = []
+      }
+
+/// JournalRequest is the form of a prayer request returned for the request journal display. It also contains
+/// properties that may be filled for history and notes.
+[<NoComparison; NoEquality>]
+type JournalRequest = {
+  /// The ID of the request (just the CUID part)
+  requestId    : RequestId
+  /// The ID of the user to whom the request belongs
+  userId       : UserId
+  /// The current text of the request
+  text         : string
+  /// The last time action was taken on the request
+  asOf         : Instant
+  /// The last status for the request
+  lastStatus   : RequestAction
+  /// The time that this request should reappear in the user's journal
+  snoozedUntil : Instant
+  /// The time after which this request should reappear in the user's journal by configured recurrence
+  showAfter    : Instant
+  /// The type of recurrence for this request
+  recurType    : Recurrence
+  /// How many of the recurrence intervals should occur between appearances in the journal
+  recurCount   : int16
+  /// History entries for the request
+  history      : History list
+  /// Note entries for the request
+  notes        : Note list
+  }
+
+/// Functions to manipulate journal requests
+module JournalRequest =
+
+  /// Convert a request to the form used for the journal (precomputed values, no notes or history)
+  let ofRequestLite (req : Request) =
+    let hist = req.history |> List.sortByDescending (fun it -> it.asOf) |> List.tryHead
+    { requestId    = req.id
+      userId       = req.userId
+      text         = req.history
+                      |> List.filter (fun it -> Option.isSome it.text)
+                      |> List.sortByDescending (fun it -> it.asOf)
+                      |> List.tryHead
+                      |> Option.map (fun h -> Option.get h.text)
+                      |> Option.defaultValue ""
+      asOf         = match hist with Some h -> h.asOf   | None -> Instant.MinValue
+      lastStatus   = match hist with Some h -> h.status | None -> Created
+      snoozedUntil = req.snoozedUntil
+      showAfter    = req.showAfter
+      recurType    = req.recurType
+      recurCount   = req.recurCount
+      history      = []
+      notes        = []
+      }
+
+  /// Same as `ofRequestLite`, but with notes and history
+  let ofRequestFull req =
+    { ofRequestLite req with 
+        history = req.history
+        notes   = req.notes
+      }
+
+
+/// Functions to manipulate request actions
+module RequestAction =
+  /// Create a string representation of an action
+  let toString =
+    function
+    | Created  -> "Created"
+    | Prayed   -> "Prayed"
+    | Updated  -> "Updated"
+    | Answered -> "Answered"
+  /// Create a RequestAction from a string
+  let ofString =
+    function
+    | "Created"  -> Created
+    | "Prayed"   -> Prayed
+    | "Updated"  -> Updated
+    | "Answered" -> Answered
+    | it         -> invalidOp $"Bad request action {it}"
+  /// Determine if a history's status is `Created`
+  let isCreated hist = hist.status = Created
+  /// Determine if a history's status is `Prayed`
+  let isPrayed hist = hist.status = Prayed
+  /// Determine if a history's status is `Answered`
+  let isAnswered hist = hist.status = Answered

src/MyPrayerJournal/Handlers.fs

@@ -0,0 +1,603 @@
+/// HTTP handlers for the myPrayerJournal API
+[<RequireQualifiedAccess>]
+module MyPrayerJournal.Handlers
+
+// fsharplint:disable RecordFieldNames
+
+open Giraffe
+open Giraffe.Htmx
+open Microsoft.AspNetCore.Authentication
+open Microsoft.AspNetCore.Http
+open System
+open System.Security.Claims
+open NodaTime
+
+/// Helper function to be able to split out log on
+[<AutoOpen>]
+module private LogOnHelpers =
+
+  /// Log on, optionally specifying a redirected URL once authentication is complete
+  let logOn url : HttpHandler =
+    fun next ctx -> backgroundTask {
+      match url with
+      | Some it ->
+          do! ctx.ChallengeAsync ("Auth0", AuthenticationProperties (RedirectUri = it))
+          return! next ctx
+      | None -> return! challenge "Auth0" next ctx
+      }
+
+/// Handlers for error conditions
+module Error =
+
+  open Microsoft.Extensions.Logging
+  open System.Threading.Tasks
+
+  /// Handle errors
+  let error (ex : Exception) (log : ILogger) =
+    log.LogError (EventId(), ex, "An unhandled exception has occurred while executing the request.")
+    clearResponse
+    >=> setStatusCode 500
+    >=> setHttpHeader "X-Toast" (sprintf "error|||%s: %s" (ex.GetType().Name) ex.Message)
+    >=> text ex.Message
+
+  /// Handle unauthorized actions, redirecting to log on for GETs, otherwise returning a 401 Not Authorized reponse
+  let notAuthorized : HttpHandler =
+    fun next ctx ->
+      (next, ctx)
+      ||> match ctx.Request.Method with
+          | "GET" -> logOn None
+          | _ -> setStatusCode 401 >=> fun _ _ -> Task.FromResult<HttpContext option> None
+
+  /// Handle 404s from the API, sending known URL paths to the Vue app so that they can be handled there
+  let notFound : HttpHandler =
+    setStatusCode 404 >=> text "Not found"
+
+
+/// Handler helpers
+[<AutoOpen>]
+module private Helpers =
+  
+  open LiteDB
+  open Microsoft.Extensions.Logging
+  open Microsoft.Net.Http.Headers
+
+  let debug (ctx : HttpContext) message =
+    let fac = ctx.GetService<ILoggerFactory>()
+    let log = fac.CreateLogger "Debug"
+    log.LogInformation message
+
+  /// Get the LiteDB database
+  let db (ctx : HttpContext) = ctx.GetService<LiteDatabase>()
+
+  /// Get the user's "sub" claim
+  let user (ctx : HttpContext) =
+    ctx.User
+    |> Option.ofObj
+    |> Option.map (fun user -> user.Claims |> Seq.tryFind (fun u -> u.Type = ClaimTypes.NameIdentifier))
+    |> Option.flatten
+    |> Option.map (fun claim -> claim.Value)
+
+  /// Get the current user's ID
+  //  NOTE: this may raise if you don't run the request through the requiresAuthentication handler first
+  let userId ctx =
+    (user >> Option.get) ctx |> UserId
+
+  /// Get the system clock
+  let clock (ctx : HttpContext) =
+    ctx.GetService<IClock> ()
+  
+  /// Get the current instant
+  let now ctx =
+    (clock ctx).GetCurrentInstant ()
+
+  /// Return a 201 CREATED response
+  let created =
+    setStatusCode 201
+
+  /// Return a 201 CREATED response with the location header set for the created resource
+  let createdAt url : HttpHandler =
+    fun next ctx ->
+      (sprintf "%s://%s%s" ctx.Request.Scheme ctx.Request.Host.Value url |> setHttpHeader HeaderNames.Location
+       >=> created) next ctx
+  
+  /// Return a 303 SEE OTHER response (forces a GET on the redirected URL)
+  let seeOther (url : string) =
+    noResponseCaching >=> setStatusCode 303 >=> setHttpHeader "Location" url
+
+  /// Render a component result
+  let renderComponent nodes : HttpHandler =
+    noResponseCaching
+    >=> fun next ctx -> backgroundTask {
+      return! ctx.WriteHtmlStringAsync (ViewEngine.RenderView.AsString.htmlNodes nodes)
+      }
+
+  open Views.Layout
+
+  /// Create a page rendering context
+  let pageContext (ctx : HttpContext) pageTitle content = backgroundTask {
+    let! hasSnoozed = backgroundTask {
+      match user ctx with
+      | Some _ -> return! Data.hasSnoozed (userId ctx) (now ctx) (db ctx)
+      | None   -> return  false
+      }
+    return {
+      isAuthenticated = (user >> Option.isSome) ctx
+      hasSnoozed      = hasSnoozed
+      currentUrl      = ctx.Request.Path.Value
+      pageTitle       = pageTitle
+      content         = content
+      }
+    }
+
+  /// Composable handler to write a view to the output
+  let writeView view : HttpHandler =
+    fun next ctx -> backgroundTask {
+      return! ctx.WriteHtmlViewAsync view
+      }
+
+  /// Hold messages across redirects
+  module Messages =
+
+    /// The messages being held
+    let mutable private messages : Map<string, (string * string)> = Map.empty
+
+    /// Locked update to prevent updates by multiple threads
+    let private upd8 = obj ()
+
+    /// Push a new message into the list
+    let push ctx message url = lock upd8 (fun () ->
+      messages <- messages.Add (ctx |> (user >> Option.get), (message, url)))
+
+    /// Add a success message header to the response
+    let pushSuccess ctx message url =
+      push ctx (sprintf "success|||%s" message) url
+    
+    /// Pop the messages for the given user
+    let pop userId = lock upd8 (fun () ->
+      let msg = messages.TryFind userId
+      msg |> Option.iter (fun _ -> messages <- messages.Remove userId)
+      msg)
+
+  /// Send a partial result if this is not a full page load (does not append no-cache headers)
+  let partialStatic (pageTitle : string) content : HttpHandler =
+    fun next ctx -> backgroundTask {
+      let  isPartial = ctx.Request.IsHtmx && not ctx.Request.IsHtmxRefresh
+      let! pageCtx   = pageContext ctx pageTitle content
+      let  view      = (match isPartial with true -> partial | false -> view) pageCtx
+      return! 
+        (next, ctx)
+        ||> match user ctx with
+            | Some u ->
+                match Messages.pop u with
+                | Some (msg, url) -> setHttpHeader "X-Toast" msg >=> withHxPush url >=> writeView view
+                | None -> writeView view
+            | None -> writeView view
+      }
+   
+  /// Send an explicitly non-cached result, rendering as a partial if this is not a full page load
+  let partial pageTitle content =
+    noResponseCaching >=> partialStatic pageTitle content
+
+  /// Add a success message header to the response
+  let withSuccessMessage : string -> HttpHandler =
+    sprintf "success|||%s" >> setHttpHeader "X-Toast"
+  
+  /// Hide a modal window when the response is sent
+  let hideModal (name : string) : HttpHandler =
+    setHttpHeader "X-Hide-Modal" name
+
+
+/// Strongly-typed models for post requests
+module Models =
+  
+  /// An additional note
+  [<CLIMutable; NoComparison; NoEquality>]
+  type NoteEntry = {
+    /// The notes being added
+    notes : string
+    }
+  
+  /// A prayer request
+  [<CLIMutable; NoComparison; NoEquality>]
+  type Request = {
+    /// The ID of the request
+    requestId     : string
+    /// Where to redirect after saving
+    returnTo      : string
+    /// The text of the request
+    requestText   : string
+    /// The additional status to record
+    status        : string option
+    /// The recurrence type
+    recurType     : string
+    /// The recurrence count
+    recurCount    : int16 option
+    /// The recurrence interval
+    recurInterval : string option
+    }
+  
+  /// The date until which a request should not appear in the journal
+  [<CLIMutable; NoComparison; NoEquality>]
+  type SnoozeUntil = {
+    /// The date (YYYY-MM-DD) at which the request should reappear
+    until : string
+    }
+
+
+open MyPrayerJournal.Data.Extensions
+open NodaTime.Text
+
+/// Handlers for less-than-full-page HTML requests
+module Components =
+
+  // GET /components/journal-items
+  let journalItems : HttpHandler =
+    requiresAuthentication Error.notAuthorized
+    >=> fun next ctx -> backgroundTask {
+      let  now   = now ctx
+      let! jrnl  = Data.journalByUserId (userId ctx) (db ctx)
+      let  shown = jrnl |> List.filter (fun it -> now > it.snoozedUntil && now > it.showAfter)
+      return! renderComponent [ Views.Journal.journalItems now shown ] next ctx
+      }
+  
+  // GET /components/request-item/[req-id]
+  let requestItem reqId : HttpHandler =
+    requiresAuthentication Error.notAuthorized
+    >=> fun next ctx -> backgroundTask {
+      match! Data.tryJournalById (RequestId.ofString reqId) (userId ctx) (db ctx) with
+      | Some req -> return! renderComponent [ Views.Request.reqListItem (now ctx) req ] next ctx
+      | None     -> return! Error.notFound next ctx
+      }
+
+  // GET /components/request/[req-id]/add-notes
+  let addNotes requestId : HttpHandler =
+    requiresAuthentication Error.notAuthorized
+    >=> renderComponent (Views.Journal.notesEdit (RequestId.ofString requestId))
+
+  // GET /components/request/[req-id]/notes
+  let notes requestId : HttpHandler =
+    requiresAuthentication Error.notAuthorized
+    >=> fun next ctx -> backgroundTask {
+      let! notes = Data.notesById (RequestId.ofString requestId) (userId ctx) (db ctx)
+      return! renderComponent (Views.Request.notes (now ctx) notes) next ctx
+      }
+  
+  // GET /components/request/[req-id]/snooze
+  let snooze requestId : HttpHandler =
+    requiresAuthentication Error.notAuthorized
+    >=> renderComponent [ RequestId.ofString requestId |> Views.Journal.snooze ]
+
+
+/// / URL    
+module Home =
+  
+  // GET /
+  let home : HttpHandler =
+    partialStatic "Welcome!" Views.Layout.home
+  
+
+/// /journal URL
+module Journal =
+  
+  // GET /journal
+  let journal : HttpHandler =
+    requiresAuthentication Error.notAuthorized
+    >=> fun next ctx -> backgroundTask {
+      let usr =
+        ctx.User.Claims
+        |> Seq.tryFind (fun c -> c.Type = ClaimTypes.GivenName)
+        |> Option.map (fun c -> c.Value)
+        |> Option.defaultValue "Your"
+      let title = usr |> match usr with "Your" -> sprintf "%s" | _ -> sprintf "%s's"
+      return! partial (sprintf "%s Prayer Journal" title) (Views.Journal.journal usr) next ctx
+    }
+
+
+/// /legal URLs
+module Legal =
+  
+  // GET /legal/privacy-policy
+  let privacyPolicy : HttpHandler =
+    partialStatic "Privacy Policy" Views.Legal.privacyPolicy
+  
+  // GET /legal/terms-of-service
+  let termsOfService : HttpHandler =
+    partialStatic "Terms of Service" Views.Legal.termsOfService
+
+
+/// /api/request and /request(s) URLs
+module Request =
+
+  // GET /request/[req-id]/edit  
+  let edit requestId : HttpHandler =
+    requiresAuthentication Error.notAuthorized
+    >=> fun next ctx -> backgroundTask {
+      let returnTo =
+        match ctx.Request.Headers.Referer.[0] with
+        | it when it.EndsWith "/active"  -> "active"
+        | it when it.EndsWith "/snoozed" -> "snoozed"
+        | _                              -> "journal"
+      match requestId with
+      | "new" ->
+          return! partial "Add Prayer Request"
+                    (Views.Request.edit (JournalRequest.ofRequestLite Request.empty) returnTo true) next ctx
+      | _     ->
+          match! Data.tryJournalById (RequestId.ofString requestId) (userId ctx) (db ctx) with
+          | Some req ->
+              debug ctx "Found - sending view"
+              return! partial "Edit Prayer Request" (Views.Request.edit req returnTo false) next ctx
+          | None     ->
+              debug ctx "Not found - uh oh..."
+              return! Error.notFound next ctx
+      }
+
+  // PATCH /request/[req-id]/prayed
+  let prayed requestId : HttpHandler =
+    requiresAuthentication Error.notAuthorized
+    >=> fun next ctx -> backgroundTask {
+      let db    = db     ctx
+      let usrId = userId ctx
+      let reqId = RequestId.ofString requestId
+      match! Data.tryRequestById reqId usrId db with
+      | Some req ->
+          let now  = now ctx
+          do! Data.addHistory reqId usrId { asOf = now; status = Prayed; text = None } db
+          let nextShow =
+            match Recurrence.duration req.recurType with
+            | 0L       -> Instant.MinValue
+            | duration -> now.Plus (Duration.FromSeconds (duration * int64 req.recurCount))
+          do! Data.updateShowAfter reqId usrId nextShow db
+          do! db.saveChanges ()
+          return! (withSuccessMessage "Request marked as prayed" >=> Components.journalItems) next ctx
+      | None -> return! Error.notFound next ctx
+      }
+  
+  /// POST /request/[req-id]/note
+  let addNote requestId : HttpHandler =
+    requiresAuthentication Error.notAuthorized
+    >=> fun next ctx -> backgroundTask {
+      let db    = db     ctx
+      let usrId = userId ctx
+      let reqId = RequestId.ofString requestId
+      match! Data.tryRequestById reqId usrId db with
+      | Some _ ->
+          let! notes = ctx.BindFormAsync<Models.NoteEntry> ()
+          do! Data.addNote reqId usrId { asOf = now ctx; notes = notes.notes } db
+          do! db.saveChanges ()
+          return! (withSuccessMessage "Added Notes" >=> hideModal "notes" >=> created) next ctx
+      | None -> return! Error.notFound next ctx
+      }
+          
+  // GET /requests/active
+  let active : HttpHandler =
+    requiresAuthentication Error.notAuthorized
+    >=> fun next ctx -> backgroundTask {
+      let! reqs = Data.journalByUserId (userId ctx) (db ctx)
+      return! partial "Active Requests" (Views.Request.active (now ctx) reqs) next ctx
+      }
+  
+  // GET /requests/snoozed
+  let snoozed : HttpHandler =
+    requiresAuthentication Error.notAuthorized
+    >=> fun next ctx -> backgroundTask {
+      let! reqs    = Data.journalByUserId (userId ctx) (db ctx)
+      let  now     = now ctx
+      let  snoozed = reqs |> List.filter (fun it -> it.snoozedUntil > now)
+      return! partial "Active Requests" (Views.Request.snoozed now snoozed) next ctx
+      }
+
+  // GET /requests/answered
+  let answered : HttpHandler =
+    requiresAuthentication Error.notAuthorized
+    >=> fun next ctx -> backgroundTask {
+      let! reqs = Data.answeredRequests (userId ctx) (db ctx)
+      return! partial "Answered Requests" (Views.Request.answered (now ctx) reqs) next ctx
+      }
+  
+  // GET /api/request/[req-id]
+  let get requestId : HttpHandler =
+    requiresAuthentication Error.notAuthorized
+    >=> fun next ctx -> backgroundTask {
+      match! Data.tryJournalById (RequestId.ofString requestId) (userId ctx) (db ctx) with
+      | Some req -> return! json req next ctx
+      | None -> return! Error.notFound next ctx
+      }
+  
+  // GET /request/[req-id]/full
+  let getFull requestId : HttpHandler =
+    requiresAuthentication Error.notAuthorized
+    >=> fun next ctx -> backgroundTask {
+      match! Data.tryFullRequestById (RequestId.ofString requestId) (userId ctx) (db ctx) with
+      | Some req -> return! partial "Prayer Request" (Views.Request.full (clock ctx) req) next ctx
+      | None     -> return! Error.notFound next ctx
+      }
+  
+  // PATCH /request/[req-id]/show
+  let show requestId : HttpHandler =
+    requiresAuthentication Error.notAuthorized
+    >=> fun next ctx -> backgroundTask {
+      let db    = db     ctx
+      let usrId = userId ctx
+      let reqId = RequestId.ofString requestId
+      match! Data.tryRequestById reqId usrId db with
+      | Some _ ->
+          do! Data.updateShowAfter reqId usrId Instant.MinValue db
+          do! db.saveChanges ()
+          return! (withSuccessMessage "Request now shown" >=> Components.requestItem requestId) next ctx
+      | None -> return! Error.notFound next ctx
+      }
+  
+  // PATCH /request/[req-id]/snooze
+  let snooze requestId : HttpHandler =
+    requiresAuthentication Error.notAuthorized
+    >=> fun next ctx -> backgroundTask {
+      let db    = db     ctx
+      let usrId = userId ctx
+      let reqId = RequestId.ofString requestId
+      match! Data.tryRequestById reqId usrId db with
+      | Some _ ->
+          let! until = ctx.BindFormAsync<Models.SnoozeUntil> ()
+          let date =
+            LocalDatePattern.CreateWithInvariantCulture("yyyy-MM-dd").Parse(until.until).Value
+              .AtStartOfDayInZone(DateTimeZone.Utc)
+              .ToInstant ()
+          do! Data.updateSnoozed reqId usrId date db
+          do! db.saveChanges ()
+          return!
+            (withSuccessMessage $"Request snoozed until {until.until}"
+             >=> hideModal "snooze"
+             >=> Components.journalItems) next ctx
+      | None -> return! Error.notFound next ctx
+      }
+  
+  // PATCH /request/[req-id]/cancel-snooze
+  let cancelSnooze requestId : HttpHandler =
+    requiresAuthentication Error.notAuthorized
+    >=> fun next ctx -> backgroundTask {
+      let db    = db     ctx
+      let usrId = userId ctx
+      let reqId = RequestId.ofString requestId
+      match! Data.tryRequestById reqId usrId db with
+      | Some _ ->
+          do! Data.updateSnoozed reqId usrId Instant.MinValue db
+          do! db.saveChanges ()
+          return! (withSuccessMessage "Request unsnoozed" >=> Components.requestItem requestId) next ctx
+      | None -> return! Error.notFound next ctx
+      }
+
+  /// Derive a recurrence and interval from its primitive representation in the form
+  let private parseRecurrence (form : Models.Request) =
+    (Recurrence.ofString (match form.recurInterval with Some x -> x | _ -> "Immediate"),
+     defaultArg form.recurCount (int16 0))
+
+  // POST /request
+  let add : HttpHandler =
+    requiresAuthentication Error.notAuthorized
+    >=> fun next ctx -> backgroundTask {
+      let! form             = ctx.BindModelAsync<Models.Request> ()
+      let  db               = db ctx
+      let  usrId            = userId ctx
+      let  now              = now ctx
+      let (recur, interval) = parseRecurrence form
+      let  req   =
+        { Request.empty with
+            userId     = usrId
+            enteredOn  = now
+            showAfter  = Instant.MinValue
+            recurType  = recur
+            recurCount = interval
+            history    = [
+              { asOf   = now
+                status = Created
+                text   = Some form.requestText
+                }      
+              ]
+          }
+      Data.addRequest req db
+      do! db.saveChanges ()
+      Messages.pushSuccess ctx "Added prayer request" "/journal"
+      return! seeOther "/journal" next ctx
+      }
+  
+  // PATCH /request
+  let update : HttpHandler =
+    requiresAuthentication Error.notAuthorized
+    >=> fun next ctx -> backgroundTask {
+      let! form  = ctx.BindModelAsync<Models.Request> ()
+      let  db    = db ctx
+      let  usrId = userId ctx
+      match! Data.tryJournalById (RequestId.ofString form.requestId) usrId db with
+      | Some req ->
+          // update recurrence if changed
+          let (recur, interval) = parseRecurrence form
+          match recur = req.recurType && interval = req.recurCount with
+          | true  -> ()
+          | false ->
+              do! Data.updateRecurrence req.requestId usrId recur interval db
+              match recur with
+              | Immediate -> do! Data.updateShowAfter req.requestId usrId Instant.MinValue db
+              | _         -> ()
+          // append history
+          let upd8Text = form.requestText.Trim ()
+          let text     = match upd8Text = req.text with true -> None | false -> Some upd8Text
+          do! Data.addHistory req.requestId usrId
+                { asOf = now ctx; status = (Option.get >> RequestAction.ofString) form.status; text = text } db
+          do! db.saveChanges ()
+          let nextUrl =
+            match form.returnTo with
+            | "active"          -> "/requests/active"
+            | "snoozed"         -> "/requests/snoozed"
+            | _ (* "journal" *) -> "/journal"
+          Messages.pushSuccess ctx "Prayer request updated successfully" nextUrl
+          return! seeOther nextUrl next ctx
+      | None -> return! Error.notFound next ctx
+      }
+
+
+/// Handlers for /user URLs
+module User =
+
+  open Microsoft.AspNetCore.Authentication.Cookies
+
+  // GET /user/log-on
+  let logOn : HttpHandler =
+    logOn (Some "/journal")
+  
+  // GET /user/log-off
+  let logOff : HttpHandler =
+    requiresAuthentication Error.notAuthorized
+    >=> fun next ctx -> task {
+      do! ctx.SignOutAsync ("Auth0", AuthenticationProperties (RedirectUri = "/"))
+      do! ctx.SignOutAsync CookieAuthenticationDefaults.AuthenticationScheme
+      return! next ctx
+    }
+
+
+open Giraffe.EndpointRouting
+
+/// The routes for myPrayerJournal
+let routes =
+  [ GET_HEAD [ route "/" Home.home ]
+    subRoute "/components/" [
+      GET_HEAD [
+        route  "journal-items"        Components.journalItems
+        routef "request/%s/add-notes" Components.addNotes
+        routef "request/%s/item"      Components.requestItem
+        routef "request/%s/notes"     Components.notes
+        routef "request/%s/snooze"    Components.snooze
+        ]
+      ]
+    GET_HEAD [ route "/journal" Journal.journal ]
+    subRoute "/legal/" [
+      GET_HEAD [
+        route "privacy-policy"   Legal.privacyPolicy
+        route "terms-of-service" Legal.termsOfService
+        ]
+      ]
+    subRoute "/request" [
+      GET_HEAD [
+        routef "/%s/edit"   Request.edit
+        routef "/%s/full"   Request.getFull
+        route  "s/active"   Request.active
+        route  "s/answered" Request.answered
+        route  "s/snoozed"  Request.snoozed
+        ]
+      PATCH [
+        route  ""                  Request.update
+        routef "/%s/cancel-snooze" Request.cancelSnooze
+        routef "/%s/prayed"        Request.prayed
+        routef "/%s/show"          Request.show
+        routef "/%s/snooze"        Request.snooze
+        ]
+      POST [
+        route  ""         Request.add
+        routef "/%s/note" Request.addNote
+        ]
+      ]
+    subRoute "/user/" [
+      GET_HEAD [
+        route "log-off" User.logOff
+        route "log-on"  User.logOn
+        ]
+      ]
+    ]

src/MyPrayerJournal/MyPrayerJournal.fsproj

@@ -0,0 +1,33 @@
+<Project Sdk="Microsoft.NET.Sdk.Web">
+  <PropertyGroup>
+    <TargetFramework>net6.0</TargetFramework>
+    <Version>3.0.0.0</Version>
+  </PropertyGroup>
+  <ItemGroup>
+    <Compile Include="Domain.fs" />
+    <Compile Include="Data.fs" />
+    <Compile Include="Dates.fs" />
+    <Compile Include="Views/Helpers.fs" />
+    <Compile Include="Views/Journal.fs" />
+    <Compile Include="Views/Layout.fs" />
+    <Compile Include="Views/Legal.fs" />
+    <Compile Include="Views/Request.fs" />
+    <Compile Include="Handlers.fs" />
+    <Compile Include="Program.fs" />
+  </ItemGroup>
+  <ItemGroup>
+    <PackageReference Include="FSharp.SystemTextJson" Version="0.17.4" />
+    <PackageReference Include="FunctionalCuid" Version="1.0.0" />
+    <PackageReference Include="Giraffe" Version="5.0.0" />
+    <PackageReference Include="LiteDB" Version="5.0.11" />
+    <PackageReference Include="Microsoft.AspNetCore.Authentication.OpenIdConnect" Version="5.0.10" />
+    <PackageReference Include="NodaTime" Version="3.0.9" />
+  </ItemGroup>
+  <ItemGroup>
+    <ProjectReference Include="../../../Giraffe.Htmx/src/Htmx/Giraffe.Htmx.fsproj" />
+    <ProjectReference Include="../../../Giraffe.Htmx/src/ViewEngine.Htmx/Giraffe.ViewEngine.Htmx.fsproj" />
+  </ItemGroup>
+  <ItemGroup>
+    <Folder Include="wwwroot\" />
+  </ItemGroup>
+</Project>

src/MyPrayerJournal/Program.fs

@@ -0,0 +1,181 @@
+module MyPrayerJournal.Api
+
+open Microsoft.AspNetCore.Builder
+open Microsoft.AspNetCore.Hosting
+open System.IO
+
+/// Configuration functions for the application
+module Configure =
+  
+  /// Configure the content root
+  let contentRoot root =
+    WebApplicationOptions (ContentRootPath = root) |> WebApplication.CreateBuilder
+
+
+  open Microsoft.Extensions.Configuration
+
+  /// Configure the application configuration
+  let appConfiguration (bldr : WebApplicationBuilder) =
+    bldr.Configuration
+      .SetBasePath(bldr.Environment.ContentRootPath)
+      .AddJsonFile("appsettings.json", optional = false, reloadOnChange = true)
+      .AddJsonFile($"appsettings.{bldr.Environment.EnvironmentName}.json", optional = true, reloadOnChange = true)
+      .AddEnvironmentVariables ()
+    |> ignore
+    bldr
+
+
+  open Microsoft.AspNetCore.Server.Kestrel.Core
+
+  /// Configure Kestrel from appsettings.json
+  let kestrel (bldr : WebApplicationBuilder) =
+    let kestrelOpts (ctx : WebHostBuilderContext) (opts : KestrelServerOptions) =
+      (ctx.Configuration.GetSection >> opts.Configure >> ignore) "Kestrel"
+    bldr.WebHost.UseKestrel().ConfigureKestrel kestrelOpts |> ignore
+    bldr
+
+
+  /// Configure the web root directory
+  let webRoot pathSegments (bldr : WebApplicationBuilder) =
+    Array.concat [ [| bldr.Environment.ContentRootPath |]; pathSegments ]
+    |> (Path.Combine >> bldr.WebHost.UseWebRoot >> ignore)
+    bldr
+
+
+  open Microsoft.Extensions.Logging
+  open Microsoft.Extensions.Hosting
+
+  /// Configure logging
+  let logging (bldr : WebApplicationBuilder) =
+    match bldr.Environment.IsDevelopment () with
+    | true -> ()
+    | false -> bldr.Logging.AddFilter (fun l -> l > LogLevel.Information) |> ignore
+    bldr.Logging.AddConsole().AddDebug() |> ignore
+    bldr
+
+
+  open Giraffe
+  open LiteDB
+  open Microsoft.AspNetCore.Authentication.Cookies
+  open Microsoft.AspNetCore.Authentication.OpenIdConnect
+  open Microsoft.AspNetCore.Http
+  open Microsoft.Extensions.DependencyInjection
+  open Microsoft.IdentityModel.Protocols.OpenIdConnect
+  open NodaTime
+  open System
+  open System.Text.Json
+  open System.Text.Json.Serialization
+  open System.Threading.Tasks
+
+  /// Configure dependency injection
+  let services (bldr : WebApplicationBuilder) =
+    let sameSite (opts : CookieOptions) =
+      match opts.SameSite, opts.Secure with
+      | SameSiteMode.None, false -> opts.SameSite <- SameSiteMode.Unspecified
+      | _, _ -> ()
+
+    bldr.Services
+      .AddRouting()
+      .AddGiraffe()
+      .AddSingleton<IClock>(SystemClock.Instance)
+      .Configure<CookiePolicyOptions>(
+        fun (opts : CookiePolicyOptions) ->
+          opts.MinimumSameSitePolicy <- SameSiteMode.Unspecified
+          opts.OnAppendCookie        <- fun ctx -> sameSite ctx.CookieOptions
+          opts.OnDeleteCookie        <- fun ctx -> sameSite ctx.CookieOptions)
+      .AddAuthentication(
+        /// Use HTTP "Bearer" authentication with JWTs
+        fun opts ->
+          opts.DefaultAuthenticateScheme <- CookieAuthenticationDefaults.AuthenticationScheme
+          opts.DefaultSignInScheme       <- CookieAuthenticationDefaults.AuthenticationScheme
+          opts.DefaultChallengeScheme    <- CookieAuthenticationDefaults.AuthenticationScheme)
+      .AddCookie()
+      .AddOpenIdConnect("Auth0",
+        /// Configure OIDC with Auth0 options from configuration
+        fun opts ->
+          let cfg = bldr.Configuration.GetSection "Auth0"
+          opts.Authority    <- sprintf "https://%s/" cfg["Domain"]
+          opts.ClientId     <- cfg["Id"]
+          opts.ClientSecret <- cfg["Secret"]
+          opts.ResponseType <- OpenIdConnectResponseType.Code
+          
+          opts.Scope.Clear ()
+          opts.Scope.Add "openid"
+          opts.Scope.Add "profile"
+
+          opts.CallbackPath <- PathString "/user/log-on/success"
+          opts.ClaimsIssuer <- "Auth0"
+          opts.SaveTokens   <- true
+
+          opts.Events <- OpenIdConnectEvents ()
+          opts.Events.OnRedirectToIdentityProviderForSignOut <- fun ctx ->
+            let returnTo =
+              match ctx.Properties.RedirectUri with
+              | it when isNull it || it = "" -> ""
+              | redirUri ->
+                  let finalRedirUri =
+                    match redirUri.StartsWith "/" with
+                    | true ->
+                        // transform to absolute
+                        let request = ctx.Request
+                        sprintf "%s://%s%s%s" request.Scheme request.Host.Value request.PathBase.Value redirUri
+                    | false -> redirUri
+                  Uri.EscapeDataString finalRedirUri |> sprintf "&returnTo=%s"
+            sprintf "https://%s/v2/logout?client_id=%s%s" cfg["Domain"] cfg["Id"] returnTo
+            |> ctx.Response.Redirect
+            ctx.HandleResponse ()
+
+            Task.CompletedTask
+          opts.Events.OnRedirectToIdentityProvider <- fun ctx ->
+            let bldr = UriBuilder ctx.ProtocolMessage.RedirectUri
+            bldr.Scheme <- cfg["Scheme"]
+            bldr.Port   <- int cfg["Port"]
+            ctx.ProtocolMessage.RedirectUri <- string bldr
+            Task.CompletedTask
+          )
+    |> ignore
+    let jsonOptions = JsonSerializerOptions ()
+    jsonOptions.Converters.Add (JsonFSharpConverter ())
+    let db = new LiteDatabase (bldr.Configuration.GetConnectionString "db")
+    Data.Startup.ensureDb db
+    bldr.Services.AddSingleton(jsonOptions)
+      .AddSingleton<Json.ISerializer, SystemTextJson.Serializer>()
+      .AddSingleton<LiteDatabase> db
+    |> ignore
+    bldr.Build ()
+  
+
+  open Giraffe.EndpointRouting
+
+  /// Configure the web application
+  let application (app : WebApplication) =
+    // match app.Environment.IsDevelopment () with
+    // | true -> app.UseDeveloperExceptionPage ()
+    // | false -> app.UseGiraffeErrorHandler Handlers.Error.error
+    // |> ignore
+    app
+      .UseStaticFiles()
+      .UseCookiePolicy()
+      .UseRouting()
+      .UseAuthentication()
+      .UseGiraffeErrorHandler(Handlers.Error.error)
+      .UseEndpoints (fun e -> e.MapGiraffeEndpoints Handlers.routes |> ignore)
+    |> ignore
+    app
+
+  /// Compose all the configurations into one
+  let webHost pathSegments =
+    contentRoot
+    >> appConfiguration
+    >> kestrel
+    >> webRoot pathSegments
+    >> logging
+    >> services
+    >> application
+
+
+[<EntryPoint>]
+let main _ =
+  use host = Configure.webHost [| "wwwroot" |] (Directory.GetCurrentDirectory ())
+  host.Run ()
+  0

src/MyPrayerJournal/Properties/launchSettings.json

@@ -0,0 +1,27 @@
+{
+  "iisSettings": {
+    "windowsAuthentication": false,
+    "anonymousAuthentication": true,
+    "iisExpress": {
+      "applicationUrl": "http://localhost:61905",
+      "sslPort": 0
+    }
+  },
+  "profiles": {
+    "IIS Express": {
+      "commandName": "IISExpress",
+      "launchBrowser": true,
+      "environmentVariables": {
+        "ASPNETCORE_ENVIRONMENT": "Development"
+      }
+    },
+    "MyPrayerJournal.Api": {
+      "commandName": "Project",
+      "launchBrowser": true,
+      "applicationUrl": "http://localhost:5000",
+      "environmentVariables": {
+        "ASPNETCORE_ENVIRONMENT": "Development"
+      }
+    }
+  }
+}

src/MyPrayerJournal/Views/Helpers.fs

@@ -0,0 +1,31 @@
+/// Internal partial views
+[<AutoOpen>]
+module private MyPrayerJournal.Views.Helpers
+  
+open Giraffe.ViewEngine
+open Giraffe.ViewEngine.Htmx
+open MyPrayerJournal
+open NodaTime
+
+/// Create a link that targets the `#top` element and pushes a URL to history
+let pageLink href attrs =
+  attrs
+  |> List.append [ _href href; _hxBoost; _hxTarget "#top"; _hxSwap HxSwap.InnerHtml; _hxPushUrl ]
+  |> a
+
+/// Create a Material icon
+let icon name = span [ _class "material-icons" ] [ str name ]
+
+/// Create a card when there are no results found
+let noResults heading link buttonText text =
+  div [ _class "card" ] [
+    h5 [ _class "card-header"] [ str heading ]
+    div [ _class "card-body text-center" ] [
+      p [ _class "card-text" ] text
+      pageLink link [ _class "btn btn-primary" ] [ str buttonText ]
+      ]
+    ]
+
+/// Create a date with a span tag, displaying the relative date with the full date/time in the tooltip
+let relativeDate (date : Instant) now =
+  span [ _title (date.ToDateTimeOffset().ToString ("f", null)) ] [ Dates.formatDistance now date |> str ]

src/MyPrayerJournal/Views/Journal.fs

@@ -0,0 +1,177 @@
+/// Views for journal pages and components
+module MyPrayerJournal.Views.Journal
+
+open Giraffe.ViewEngine
+open Giraffe.ViewEngine.Accessibility
+open Giraffe.ViewEngine.Htmx
+open MyPrayerJournal
+
+/// Display a card for this prayer request
+let journalCard now req =
+  let reqId = RequestId.toString req.requestId
+  let spacer = span [] [ rawText " " ]
+  div [ _class "col" ] [
+    div [ _class "card h-100" ] [
+      div [ _class "card-header p-0 d-flex"; _roleToolBar ] [
+        pageLink $"/request/{reqId}/edit" [ _class  "btn btn-secondary"; _title "Edit Request" ] [ icon "edit" ]
+        spacer
+        button [
+          _type     "button"
+          _class    "btn btn-secondary"
+          _title    "Add Notes"
+          _data     "bs-toggle" "modal"
+          _data     "bs-target" "#notesModal"
+          _hxGet    $"/components/request/{reqId}/add-notes"
+          _hxTarget "#notesBody"
+          _hxSwap   HxSwap.InnerHtml
+          ] [ icon "comment" ]
+        spacer
+        button [
+          _type     "button"
+          _class    "btn btn-secondary"
+          _title    "Snooze Request"
+          _data     "bs-toggle" "modal"
+          _data     "bs-target" "#snoozeModal"
+          _hxGet    $"/components/request/{reqId}/snooze"
+          _hxTarget "#snoozeBody"
+          _hxSwap   HxSwap.InnerHtml
+          ] [ icon "schedule" ]
+        div [ _class "flex-grow-1" ] []
+        button [
+          _type    "button"
+          _class   "btn btn-success w-25"
+          _hxPatch $"/request/{reqId}/prayed"
+          _title   "Mark as Prayed"
+          ] [ icon "done" ]
+        ]
+      div [ _class "card-body" ] [
+        p [ _class "request-text" ] [ str req.text ]
+        ]
+      div [ _class "card-footer text-end text-muted px-1 py-0" ] [
+        em [] [ str "last activity "; relativeDate req.asOf now ]
+        ]
+      ]
+    ]
+
+/// The journal loading page
+let journal user = article [ _class "container-fluid mt-3" ] [
+  h2 [ _class "pb-3" ] [
+    str user
+    match user with "Your" -> () | _ -> rawText "’s"
+    str " Prayer Journal"
+    ]
+  p [ _class "pb-3 text-center" ] [
+    pageLink "/request/new/edit" [ _class "btn btn-primary "] [ icon "add_box"; str " Add a Prayer Request" ]
+    ]
+  p [ _hxGet "/components/journal-items"; _hxSwap HxSwap.OuterHtml; _hxTrigger HxTrigger.Load ] [
+    rawText "Loading your prayer journal…"
+    ]
+  div [
+    _id             "notesModal"
+    _class          "modal fade"
+    _tabindex       "-1"
+    _ariaLabelledBy "nodesModalLabel"
+    _ariaHidden     "true"
+    ] [
+    div [ _class "modal-dialog modal-dialog-scrollable" ] [
+      div [ _class "modal-content" ] [
+        div [ _class "modal-header" ] [
+          h5 [ _class "modal-title"; _id "nodesModalLabel" ] [ str "Add Notes to Prayer Request" ]
+          button [ _type "button"; _class "btn-close"; _data "bs-dismiss" "modal"; _ariaLabel "Close" ] []
+          ]
+        div [ _class "modal-body"; _id "notesBody" ] [ ]
+        div [ _class "modal-footer" ] [
+          button [ _type "button"; _id "notesDismiss"; _class "btn btn-secondary"; _data "bs-dismiss" "modal" ] [
+            str "Close"
+            ]
+          ]
+        ]
+      ]
+    ]
+  div [
+    _id             "snoozeModal"
+    _class          "modal fade"
+    _tabindex       "-1"
+    _ariaLabelledBy "snoozeModalLabel"
+    _ariaHidden     "true"
+    ] [
+    div [ _class "modal-dialog modal-sm" ] [
+      div [ _class "modal-content" ] [
+        div [ _class "modal-header" ] [
+          h5 [ _class "modal-title"; _id "snoozeModalLabel" ] [ str "Snooze Prayer Request" ]
+          button [ _type "button"; _class "btn-close"; _data "bs-dismiss" "modal"; _ariaLabel "Close" ] []
+          ]
+        div [ _class "modal-body"; _id "snoozeBody" ] [ ]
+        div [ _class "modal-footer" ] [
+          button [ _type "button"; _id "snoozeDismiss"; _class "btn btn-secondary"; _data "bs-dismiss" "modal" ] [
+            str "Close"
+            ]
+          ]
+        ]
+      ]
+    ]
+  ]
+
+/// The journal items
+let journalItems now items =
+  match items |> List.isEmpty with
+  | true ->
+      noResults "No Active Requests" "/request/new/edit" "Add a Request" [
+        rawText "You have no requests to be shown; see the “Active” link above for snoozed or deferred "
+        rawText "requests, and the “Answered” link for answered requests"
+        ]
+  | false ->
+      items
+      |> List.map (journalCard now)
+      |> section [
+          _id       "journalItems"
+          _class    "row row-cols-1 row-cols-md-2 row-cols-lg-3 row-cols-xl-4 g-3"
+          _hxTarget "this"
+          _hxSwap   HxSwap.OuterHtml
+          ]
+
+/// The notes edit modal body
+let notesEdit requestId =
+  let reqId = RequestId.toString requestId
+  [ form [ _hxPost $"/request/{reqId}/note" ] [
+      div [ _class "form-floating pb-3" ] [
+        textarea [
+          _id          "notes"
+          _name        "notes"
+          _class       "form-control"
+          _style       "min-height: 8rem;"
+          _placeholder "Notes"
+          _autofocus;  _required
+          ] [ ]
+        label [ _for "notes" ] [ str "Notes" ]
+        ]
+      p [ _class "text-end" ] [ button [ _type "submit"; _class "btn btn-primary" ] [ str "Add Notes" ] ]
+      ]
+    hr [ _style "margin: .5rem -1rem" ]
+    div [ _id "priorNotes" ] [
+      p [ _class "text-center pt-3" ] [
+        button [
+          _type     "button"
+          _class    "btn btn-secondary"
+          _hxGet    $"/components/request/{reqId}/notes"
+          _hxSwap   HxSwap.OuterHtml
+          _hxTarget "#priorNotes"
+          ] [str "Load Prior Notes" ]
+        ]
+      ]
+    ]
+
+/// The snooze edit form
+let snooze requestId =
+  let today = System.DateTime.Today.ToString "yyyy-MM-dd"
+  form [
+    _hxPatch  $"/request/{RequestId.toString requestId}/snooze"
+    _hxTarget "#journalItems"
+    _hxSwap   HxSwap.OuterHtml
+    ] [
+    div [ _class "form-floating pb-3" ] [
+      input [ _type "date"; _id "until"; _name "until"; _class "form-control"; _min today; _required ]
+      label [ _for "until" ] [ str "Until" ]
+      ]
+    p [ _class "text-end mb-0" ] [ button [ _type "submit"; _class "btn btn-primary" ] [ str "Snooze" ] ]
+    ]

src/MyPrayerJournal/Views/Layout.fs

@@ -0,0 +1,151 @@
+/// Layout / home views
+module MyPrayerJournal.Views.Layout
+
+// fsharplint:disable RecordFieldNames
+
+open Giraffe.ViewEngine
+open Giraffe.ViewEngine.Accessibility
+
+/// The data needed to render a page-level view
+type PageRenderContext = {
+  /// Whether the user is authenticated
+  isAuthenticated : bool
+  /// Whether the user has snoozed requests
+  hasSnoozed      : bool
+  /// The current URL
+  currentUrl      : string
+  /// The title for the page to be rendered
+  pageTitle       : string
+  /// The content of the page
+  content         : XmlNode
+  }
+
+/// The home page
+let home = article [ _class "container mt-3" ] [
+  p [] [ rawText " " ]
+  p [] [
+    str "myPrayerJournal is a place where individuals can record their prayer requests, record that they prayed for "
+    str "them, update them as God moves in the situation, and record a final answer received on that request. It also "
+    str "allows individuals to review their answered prayers."
+    ]
+  p [] [
+    str "This site is open and available to the general public. To get started, simply click the "
+    rawText "“Log On” link above, and log on with either a Microsoft or Google account. You can also "
+    rawText "learn more about the site at the “Docs” link, also above."
+    ]
+  ]
+
+/// The default navigation bar, which will load the items on page load, and whenever a refresh event occurs
+let private navBar ctx =
+  nav [ _class "navbar navbar-dark"; _roleNavigation ] [
+    div [ _class "container-fluid" ] [
+      pageLink "/" [ _class "navbar-brand" ] [
+        span [ _class "m" ] [ str "my" ]
+        span [ _class "p" ] [ str "Prayer" ]
+        span [ _class "j" ] [ str "Journal" ]
+      ]
+      seq {
+        let navLink (matchUrl : string) =
+          match ctx.currentUrl.StartsWith matchUrl with true -> [ _class "is-active-route" ] | false -> []
+          |> pageLink matchUrl
+        match ctx.isAuthenticated with
+        | true ->
+            li [ _class "nav-item" ] [ navLink "/journal" [ str "Journal" ] ]
+            li [ _class "nav-item" ] [ navLink "/requests/active" [ str "Active" ] ]
+            if ctx.hasSnoozed then li [ _class "nav-item" ] [ navLink "/requests/snoozed" [ str "Snoozed" ] ]
+            li [ _class "nav-item" ] [ navLink "/requests/answered" [ str "Answered" ] ]
+            li [ _class "nav-item" ] [ a [ _href "/user/log-off" ] [ str "Log Off" ] ]
+        | false -> li [ _class "nav-item"] [ a [ _href "/user/log-on" ] [ str "Log On" ] ]
+        li [ _class "nav-item" ] [
+          a [ _href "https://docs.prayerjournal.me"; _target "_blank"; _rel "noopener" ] [ str "Docs" ]
+          ]
+        }
+      |> List.ofSeq
+      |> ul [ _class "navbar-nav me-auto d-flex flex-row" ]
+      ]
+    ]
+
+/// The title tag with the application name appended
+let titleTag ctx = title [] [ str ctx.pageTitle; rawText " « myPrayerJournal" ]
+
+/// The HTML `head` element
+let htmlHead ctx =
+  head [ _lang "en" ] [
+    meta [ _name "viewport"; _content "width=device-width, initial-scale=1" ]
+    meta [ _name "description"; _content "Online prayer journal - free w/Google or Microsoft account" ]
+    titleTag ctx
+    link [
+      _href        "https://cdn.jsdelivr.net/npm/bootstrap@5.0.2/dist/css/bootstrap.min.css"
+      _rel         "stylesheet"
+      _integrity   "sha384-EVSTQN3/azprG1Anm3QDgpJLIm9Nao0Yz1ztcQTwFspd3yD65VohhpuuCOmLASjC"
+      _crossorigin "anonymous"
+      ]
+    link [ _href "https://fonts.googleapis.com/icon?family=Material+Icons"; _rel "stylesheet" ]
+    link [ _href "/style/style.css"; _rel "stylesheet" ]
+    ]
+
+/// Element used to display toasts
+let toaster =
+  div [ _ariaLive "polite"; _ariaAtomic "true"; _id "toastHost" ] [
+    div [ _class "toast-container position-absolute p-3 bottom-0 end-0"; _id "toasts" ] []
+  ]
+
+/// The page's `footer` element
+let htmlFoot =
+  footer [ _class "container-fluid" ] [
+    p [ _class "text-muted text-end" ] [
+      str "myPrayerJournal v3"
+      br []
+      em [] [
+        small [] [
+          pageLink "/legal/privacy-policy" [] [ str "Privacy Policy" ]
+          rawText " • "
+          pageLink "/legal/terms-of-service" [] [ str "Terms of Service" ]
+          rawText " • "
+          a [ _href "https://github.com/bit-badger/myprayerjournal"; _target "_blank"; _rel "noopener" ] [
+            str "Developed"
+            ]
+          str " and hosted by "
+          a [ _href "https://bitbadger.solutions"; _target "_blank"; _rel "noopener" ] [ str "Bit Badger Solutions" ]
+          ]
+        ]
+      ]
+    script [
+      _src         "https://unpkg.com/htmx.org@1.5.0"
+      _integrity   "sha384-oGA+prIp5Vchu6we2YkI51UtVzN9Jpx2Z7PnR1I78PnZlN8LkrCT4lqqqmDkyrvI"
+      _crossorigin "anonymous"
+      ] []
+    script [] [
+      rawText "if (!htmx) document.write('<script src=\"/script/htmx-1.5.0.min.js\"><\/script>')"
+      ]
+    script [
+      _async
+      _src         "https://cdn.jsdelivr.net/npm/bootstrap@5.0.2/dist/js/bootstrap.bundle.min.js"
+      _integrity   "sha384-MrcW6ZMFYlzcLA8Nl+NtUVF0sA7MsXsP1UyJoMp4YLEuNSfAP+JcXn/tWtIaxVXM"
+      _crossorigin "anonymous"
+      ] []
+    script [] [
+      rawText "setTimeout(function () { "
+      rawText "if (!bootstrap) document.write('<script src=\"/script/bootstrap.bundle.min.js\"><\/script>') "
+      rawText "}, 2000)"
+      ]
+    script [ _src "/script/mpj.js" ] []
+    ]
+
+/// Create the full view of the page
+let view ctx =
+  html [ _lang "en" ] [
+    htmlHead ctx
+    body [] [
+      section [ _id "top" ] [ navBar ctx; main [ _roleMain ] [ ctx.content ] ]
+      toaster
+      htmlFoot
+      ]
+    ]
+
+/// Create a partial view
+let partial ctx =
+  html [ _lang "en" ] [
+    head [] [ titleTag ctx ]
+    body [] [ navBar ctx; main [ _roleMain ] [ ctx.content ] ]
+    ]

src/MyPrayerJournal/Views/Legal.fs

@@ -0,0 +1,153 @@
+/// Views for legal pages
+module MyPrayerJournal.Views.Legal
+
+open Giraffe.ViewEngine
+
+/// View for the "Privacy Policy" page
+let privacyPolicy = article [ _class "container mt-3" ] [
+  h2 [ _class "mb-2" ] [ str "Privacy Policy" ]
+  h6 [ _class "text-muted pb-3" ] [ str "as of May 21"; sup [] [ str "st"]; str ", 2018" ]
+  p [] [
+    str "The nature of the service is one where privacy is a must. The items below will help you understand the data "
+    str "we collect, access, and store on your behalf as you use this service."
+    ]
+  div [ _class "card" ] [
+    div [ _class "list-group list-group-flush" ] [
+      div [ _class "list-group-item"] [
+        h3 [] [ str "Third Party Services" ]
+        p [ _class "card-text" ] [
+          str "myPrayerJournal utilizes a third-party authentication and identity provider. You should familiarize "
+          str "yourself with the privacy policy for "
+          a [ _href "https://auth0.com/privacy"; _target "_blank" ] [ str "Auth0" ]
+          str ", as well as your chosen provider ("
+          a [ _href "https://privacy.microsoft.com/en-us/privacystatement"; _target "_blank" ] [ str "Microsoft"]
+          str " or "
+          a [ _href "https://policies.google.com/privacy"; _target "_blank" ] [ str "Google" ]
+          str ")."
+          ]
+        ]
+      div [ _class "list-group-item" ] [
+        h3 [] [ str "What We Collect" ]
+        h4 [] [ str "Identifying Data" ]
+        ul [] [
+          li [] [
+            rawText "The only identifying data myPrayerJournal stores is the subscriber (“sub”) field from "
+            str "the token we receive from Auth0, once you have signed in through their hosted service. All "
+            str "information is associated with you via this field."
+            ]
+          li [] [
+            str "While you are signed in, within your browser, the service has access to your first and last names, "
+            str "along with a URL to the profile picture (provided by your selected identity provider). This "
+            rawText "information is not transmitted to the server, and is removed when “Log Off” is "
+            str "clicked."
+            ]
+          ]
+        h4 [] [ str "User Provided Data" ]
+        ul [ _class "mb-0" ] [
+          li [] [
+            str "myPrayerJournal stores the information you provide, including the text of prayer requests, updates, "
+            str "and notes; and the date/time when certain actions are taken."
+            ]
+          ]
+        ]
+      div [ _class "list-group-item" ] [
+        h3 [] [ str "How Your Data Is Accessed / Secured" ]
+        ul [ _class "mb-0" ] [
+          li [] [
+            str "Your provided data is returned to you, as required, to display your journal or your answered "
+            str "requests. On the server, it is stored in a controlled-access database."
+            ]
+          li [] [
+            str "Your data is backed up, along with other Bit Badger Solutions hosted systems, in a rolling manner; "
+            str "backups are preserved for the prior 7 days, and backups from the 1"
+            sup [] [ str "st" ]
+            str " and 15"
+            sup [] [ str "th" ]
+            str " are preserved for 3 months. These backups are stored in a private cloud data repository."
+            ]
+          li [] [
+            str "The data collected and stored is the absolute minimum necessary for the functionality of the service. "
+            rawText "There are no plans to “monetize” this service, and storing the minimum amount of "
+            str "information means that the data we have is not interesting to purchasers (or those who may have more "
+            str "nefarious purposes)."
+            ]
+          li [] [
+            str "Access to servers and backups is strictly controlled and monitored for unauthorized access attempts."
+            ]
+          ]
+        ]
+      div [ _class "list-group-item" ] [
+        h3 [] [ str "Removing Your Data" ]
+        p [ _class "card-text" ] [
+          str "At any time, you may choose to discontinue using this service. Both Microsoft and Google provide ways "
+          str "to revoke access from this application. However, if you want your data removed from the database, "
+          str "please contact daniel at bitbadger.solutions (via e-mail, replacing at with @) prior to doing so, to "
+          str "ensure we can determine which subscriber ID belongs to you."
+          ]
+        ]
+      ]
+    ]
+  ]
+
+/// View for the "Terms of Service" page
+let termsOfService = article [ _class "container mt-3" ] [
+  h2 [ _class "mb-2" ] [ str "Terms of Service" ]
+  h6 [ _class "text-muted pb-3"] [ str "as of May 21"; sup [] [ str "st" ]; str ", 2018" ]
+  div [ _class "card" ] [
+    div [ _class "list-group list-group-flush" ] [
+      div [ _class "list-group-item" ] [
+        h3 [] [ str "1. Acceptance of Terms" ]
+        p [ _class "card-text" ] [
+          str "By accessing this web site, you are agreeing to be bound by these Terms and Conditions, and that you "
+          str "are responsible to ensure that your use of this site complies with all applicable laws. Your continued "
+          str "use of this site implies your acceptance of these terms."
+          ]
+        ]
+      div [ _class "list-group-item" ] [
+        h3 [] [ str "2. Description of Service and Registration" ]
+        p [ _class "card-text" ] [
+          str "myPrayerJournal is a service that allows individuals to enter and amend their prayer requests. It "
+          str "requires no registration by itself, but access is granted based on a successful login with an external "
+          str "identity provider. See "
+          pageLink "/legal/privacy-policy" [] [ str "our privacy policy" ]
+          str " for details on how that information is accessed and stored."
+          ]
+        ]
+      div [ _class "list-group-item" ] [
+        h3 [] [ str "3. Third Party Services" ]
+        p [ _class "card-text" ] [
+          str "This service utilizes a third-party service provider for identity management. Review the terms of "
+          str "service for "
+          a [ _href "https://auth0.com/terms"; _target "_blank" ] [ str "Auth0"]
+          str ", as well as those for the selected authorization provider ("
+          a [ _href "https://www.microsoft.com/en-us/servicesagreement"; _target "_blank" ] [ str "Microsoft"]
+          str " or "
+          a [ _href "https://policies.google.com/terms"; _target "_blank" ] [ str "Google" ]
+          str ")."
+          ]
+        ]
+      div [ _class "list-group-item" ] [
+        h3 [] [ str "4. Liability" ]
+        p [ _class "card-text" ] [
+          rawText "This service is provided “as is”, and no warranty (express or implied) exists. The "
+          str "service and its developers may not be held liable for any damages that may arise through the use of "
+          str "this service."
+          ]
+        ]
+      div [ _class "list-group-item" ] [
+        h3 [] [ str "5. Updates to Terms" ]
+        p [ _class "card-text" ] [
+          str "These terms and conditions may be updated at any time, and this service does not have the capability to "
+          str "notify users when these change. The date at the top of the page will be updated when any of the text of "
+          str "these terms is updated."
+          ]
+        ]
+      ]
+    ]
+  p [ _class "pt-3" ] [
+    str "You may also wish to review our "
+    pageLink "/legal/privacy-policy" [] [ str "privacy policy" ]
+    str " to learn how we handle your data."
+    ]
+  ]
+

src/MyPrayerJournal/Views/Request.fs

@@ -0,0 +1,268 @@
+/// Views for request pages and components
+module MyPrayerJournal.Views.Request
+
+open Giraffe.ViewEngine
+open Giraffe.ViewEngine.Htmx
+open MyPrayerJournal
+open NodaTime
+open System
+
+/// Create a request within the list
+let reqListItem now req =
+  let reqId      = RequestId.toString req.requestId
+  let isAnswered = req.lastStatus = Answered
+  let isSnoozed  = req.snoozedUntil > now
+  let isPending  = (not isSnoozed) && req.showAfter > now
+  let btnClass   = _class "btn btn-light mx-2"
+  let restoreBtn (link : string) title =
+    button [ btnClass; _hxPatch $"/request/{reqId}/{link}"; _title title ] [ icon "restore" ]
+  div [ _class "list-group-item px-0 d-flex flex-row align-items-start"; _hxTarget "this"; _hxSwap HxSwap.OuterHtml ] [
+    pageLink $"/request/{reqId}/full" [ btnClass; _title "View Full Request" ] [ icon "description" ]
+    match isAnswered with
+    | true  -> ()
+    | false -> pageLink $"/request/{reqId}/edit" [ btnClass; _title "Edit Request" ] [ icon "edit" ]
+    match true with
+    | _ when isSnoozed -> restoreBtn "cancel-snooze" "Cancel Snooze"
+    | _ when isPending -> restoreBtn "show"          "Show Now"
+    | _ -> ()
+    p [ _class "request-text mb-0" ] [
+      str req.text
+      match isSnoozed || isPending || isAnswered with
+      | true ->
+          br []
+          small [ _class "text-muted" ] [
+            match () with
+            | _ when isSnoozed   -> [ str "Snooze expires ";       relativeDate req.snoozedUntil now ]
+            | _ when isPending   -> [ str "Request appears next "; relativeDate req.showAfter    now ]
+            | _ (* isAnswered *) -> [ str "Answered ";             relativeDate req.asOf         now ]
+            |> em []
+            ]
+      | false -> ()
+      ]
+    ]
+
+/// Create a list of requests
+let reqList now reqs =
+  reqs
+  |> List.map (reqListItem now)
+  |> div [ _class "list-group" ]
+
+/// View for Active Requests page
+let active now reqs = article [ _class "container mt-3" ] [
+  h2 [ _class "pb-3" ] [ str "Active Requests" ]
+  match reqs |> List.isEmpty with
+  | true ->
+      noResults "No Active Requests" "/journal" "Return to your journal"
+        [ str "Your prayer journal has no active requests" ]
+  | false -> reqList now reqs
+  ]
+
+/// View for Answered Requests page
+let answered now reqs = article [ _class "container mt-3" ] [
+  h2 [ _class "pb-3" ] [ str "Answered Requests" ]
+  match reqs |> List.isEmpty with
+  | true ->
+      noResults "No Active Requests" "/journal" "Return to your journal" [
+        rawText "Your prayer journal has no answered requests; once you have marked one as “Answered”, "
+        str "it will appear here"
+        ]
+  | false -> reqList now reqs
+  ]
+
+/// View for Snoozed Requests page
+let snoozed now reqs = article [ _class "container mt-3" ] [
+  h2 [ _class "pb-3" ] [ str "Snoozed Requests" ]
+  reqList now reqs
+  ]
+
+/// View for Full Request page
+let full (clock : IClock) (req : Request) =
+  let now = clock.GetCurrentInstant ()
+  let answered =
+    req.history
+    |> List.filter RequestAction.isAnswered
+    |> List.tryHead
+    |> Option.map (fun x -> x.asOf)
+  let prayed = (req.history |> List.filter RequestAction.isPrayed |> List.length).ToString "N0"
+  let daysOpen =
+    let asOf = defaultArg answered now
+    ((asOf - (req.history |> List.filter RequestAction.isCreated |> List.head).asOf).TotalDays |> int).ToString "N0"
+  let lastText =
+    req.history
+    |> List.filter (fun h -> Option.isSome h.text)
+    |> List.sortByDescending (fun h -> h.asOf)
+    |> List.map (fun h -> Option.get h.text)
+    |> List.head
+  // The history log including notes (and excluding the final entry for answered requests)
+  let log =
+    let toDisp (h : History) = {| asOf = h.asOf; text = h.text; status = RequestAction.toString h.status |}
+    let all =
+      req.notes
+      |> List.map (fun n -> {| asOf = n.asOf; text = Some n.notes; status = "Notes" |})
+      |> List.append (req.history |> List.map toDisp)
+      |> List.sortByDescending (fun it -> it.asOf)
+    // Skip the first entry for answered requests; that info is already displayed
+    match answered with Some _ -> all |> List.skip 1 | None -> all
+  article [ _class "container mt-3" ] [
+    div [_class "card" ] [
+      h5 [ _class "card-header" ] [ str "Full Prayer Request" ]
+      div [ _class "card-body" ] [
+        h6 [ _class "card-subtitle text-muted mb-2"] [
+          match answered with
+          | Some date ->
+              str "Answered "
+              date.ToDateTimeOffset().ToString ("D", null) |> str
+              str " ("
+              relativeDate date now
+              rawText ") • "
+          | None -> ()
+          sprintf "Prayed %s times • Open %s days" prayed daysOpen |> rawText
+          ]
+        p [ _class "card-text" ] [ str lastText ]
+        ]
+      log
+      |> List.map (fun it -> li [ _class "list-group-item" ] [
+        p [ _class "m-0" ] [
+          str it.status
+          rawText "  "
+          small [] [ em [] [ it.asOf.ToDateTimeOffset().ToString ("D", null) |> str ] ]
+          ]
+        match it.text with
+        | Some txt -> p [ _class "mt-2 mb-0" ] [ str txt ]
+        | None -> ()
+      ])
+      |> ul [ _class "list-group list-group-flush" ]
+      ]
+    ]
+
+/// View for the edit request component
+let edit (req : JournalRequest) returnTo isNew =
+  let cancelLink =
+    match returnTo with
+    | "active"          -> "/requests/active"
+    | "snoozed"         -> "/requests/snoozed"
+    | _ (* "journal" *) -> "/journal"
+  article [ _class "container" ] [
+    h2 [ _class "pb-3" ] [ (match isNew with true -> "Add" | false -> "Edit") |> strf "%s Prayer Request" ]
+    form [
+      _hxBoost
+      _hxTarget "#top"
+      _hxPushUrl
+      "/request" |> match isNew with true -> _hxPost | false -> _hxPatch
+      ] [
+      input [
+        _type  "hidden"
+        _name  "requestId"
+        _value (match isNew with true -> "new" | false -> RequestId.toString req.requestId)
+        ]
+      input [ _type "hidden"; _name "returnTo"; _value returnTo ]
+      div [ _class "form-floating pb-3" ] [
+        textarea [
+          _id          "requestText"
+          _name        "requestText"
+          _class       "form-control"
+          _style       "min-height: 8rem;"
+          _placeholder "Enter the text of the request"
+          _autofocus;  _required
+          ] [ str req.text ]
+        label [ _for "requestText" ] [ str "Prayer Request" ]
+        ]
+      br []
+      match isNew with
+      | true -> ()
+      | false ->
+          div [ _class "pb-3" ] [
+            label [] [ str "Also Mark As" ]
+            br []
+            div [ _class "form-check form-check-inline" ] [
+              input [ _type "radio"; _class "form-check-input"; _id "sU"; _name "status"; _value "Updated"; _checked ]
+              label [ _for "sU" ] [ str "Updated" ]
+              ]
+            div [ _class "form-check form-check-inline" ] [
+              input [ _type "radio"; _class "form-check-input"; _id "sP"; _name "status"; _value "Prayed" ]
+              label [ _for "sP" ] [ str "Prayed" ]
+              ]
+            div [ _class "form-check form-check-inline" ] [
+              input [ _type "radio"; _class "form-check-input"; _id "sA"; _name "status"; _value "Answered" ]
+              label [ _for "sA" ] [ str "Answered" ]
+              ]
+            ]
+      div [ _class "row" ] [
+        div [ _class "col-12 offset-md-2 col-md-8 offset-lg-3 col-lg-6" ] [
+          p [] [
+            strong [] [ rawText "Recurrence   " ]
+            em [ _class "text-muted" ] [ rawText "After prayer, request reappears…" ]
+            ]
+          div [ _class "d-flex flex-row flex-wrap justify-content-center align-items-center" ] [
+            div [ _class "form-check mx-2" ] [
+              input [
+                _type    "radio"
+                _class   "form-check-input"
+                _id      "rI"
+                _name    "recurType"
+                _value   "Immediate"
+                _onclick "mpj.edit.toggleRecurrence(event)"
+                match req.recurType with Immediate -> _checked | _ -> ()
+                ]
+              label [ _for "rI" ] [ str "Immediately" ]
+              ]
+            div [ _class "form-check mx-2"] [
+              input [
+                _type    "radio"
+                _class   "form-check-input"
+                _id      "rO"
+                _name    "recurType"
+                _value   "Other"
+                _onclick "mpj.edit.toggleRecurrence(event)"
+                match req.recurType with Immediate -> () | _ -> _checked
+                ]
+              label [ _for "rO" ] [ rawText "Every…" ]
+              ]
+            div [ _class "form-floating mx-2"] [
+              input [
+                _type        "number"
+                _class       "form-control"
+                _id          "recurCount"
+                _name        "recurCount"
+                _placeholder "0"
+                _value       (string req.recurCount)
+                _style       "width:6rem;"
+                _required
+                match req.recurType with Immediate -> _disabled | _ -> ()
+                ]
+              label [ _for "recurCount" ] [ str "Count" ]
+              ]
+            div [ _class "form-floating mx-2" ] [
+              select [
+                _class    "form-control"
+                _id       "recurInterval"
+                _name     "recurInterval"
+                _style    "width:6rem;"
+                _required
+                match req.recurType with Immediate -> _disabled | _ -> ()
+                ] [
+                option [ _value "Hours"; match req.recurType with Hours -> _selected | _ -> () ] [ str "hours" ]
+                option [ _value "Days";  match req.recurType with Days  -> _selected | _ -> () ] [ str "days" ]
+                option [ _value "Weeks"; match req.recurType with Weeks -> _selected | _ -> () ] [ str "weeks" ]
+                ]
+              label [ _form "recurInterval" ] [ str "Interval" ]
+              ]
+            ]
+          ]
+        ]
+      div [ _class "text-end pt-3" ] [
+        button [ _class "btn btn-primary me-2"; _type "submit" ] [ icon "save"; str " Save" ]
+        pageLink cancelLink [ _class "btn btn-secondary ms-2" ] [ icon "arrow_back"; str " Cancel" ]
+        ]
+      ]
+    ]
+
+/// Display a list of notes for a request
+let notes now notes =
+  let toItem (note : Note) =
+    p [] [ small [ _class "text-muted" ] [ relativeDate note.asOf now ]; br []; str note.notes ]
+  [ p [ _class "text-center" ] [ strong [] [ str "Prior Notes for This Request" ] ]
+    match notes with
+    | [] -> p [ _class "text-center text-muted" ] [ str "There are no prior notes for this request" ]
+    | _  -> yield! notes |> List.map toItem
+    ]

src/MyPrayerJournal/appsettings.json

@@ -0,0 +1,12 @@
+{
+  "ConnectionStrings": {
+    "db": "Filename=./mpj.db"
+  },
+  "Kestrel": {
+    "EndPoints": {
+      "Http": {
+        "Url": "http://localhost:3000"
+      }
+    }
+  }
+}

src/MyPrayerJournal/wwwroot/script/mpj.js

@@ -0,0 +1,82 @@
+"use strict"
+
+/** myPrayerJournal script */
+const mpj = {
+  /**
+   * Show a message via toast
+   * @param {string} message The message to show
+   */
+  showToast (message) {
+    const [level, msg] = message.split("|||")
+    
+    let header
+    if (level !== "success") {
+      const heading = typ => `<span class="me-auto"><strong>${typ.toUpperCase()}</strong></span>`
+      
+      header = document.createElement("div")
+      header.className = "toast-header"
+      header.innerHTML = heading(level === "warning" ? level : "error")
+      
+      const close = document.createElement("button")
+      close.type = "button"
+      close.className = "btn-close"
+      close.setAttribute("data-bs-dismiss", "toast")
+      close.setAttribute("aria-label", "Close")
+      header.appendChild(close)
+    }
+
+    const body = document.createElement("div")
+    body.className = "toast-body"
+    body.innerText = msg
+    
+    const toastEl = document.createElement("div")
+    toastEl.className = `toast bg-${level === "error" ? "danger" : level} text-white`
+    toastEl.setAttribute("role", "alert")
+    toastEl.setAttribute("aria-live", "assertlive")
+    toastEl.setAttribute("aria-atomic", "true")
+    toastEl.addEventListener("hidden.bs.toast", e => e.target.remove())
+    if (header) toastEl.appendChild(header)
+    
+    toastEl.appendChild(body)
+    document.getElementById("toasts").appendChild(toastEl)
+    new bootstrap.Toast(toastEl, { autohide: level === "success" }).show()
+  },
+  /**
+   * Load local version of Bootstrap CSS if the CDN load failed
+   */
+  ensureCss () {
+    let loaded = false
+    for (let i = 0; !loaded && i < document.styleSheets.length; i++) {
+      loaded = document.styleSheets[i].href.endsWith("bootstrap.min.css")
+    }
+    if (!loaded) {
+      const css = document.createElement("link")
+      css.rel = "stylesheet"
+      css.href = "/style/bootstrap.min.css"
+      document.getElementsByTagName("head")[0].appendChild(css)
+    }
+  },
+  /** Script for the request edit component */
+  edit: {
+    /**
+     * Toggle the recurrence input fields
+     * @param {Event} e The click event
+     */
+    toggleRecurrence ({ target }) {
+      const isDisabled = target.value === "Immediate"
+      ;["recurCount", "recurInterval"].forEach(it => document.getElementById(it).disabled = isDisabled)
+    }
+  }
+}
+
+htmx.on("htmx:afterOnLoad", function (evt) {
+  const hdrs = evt.detail.xhr.getAllResponseHeaders()
+  // Show a message if there was one in the response
+  if (hdrs.indexOf("x-toast") >= 0) {
+    mpj.showToast(evt.detail.xhr.getResponseHeader("x-toast"))
+  }
+  // Hide a modal window if requested
+  if (hdrs.indexOf("x-hide-modal") >= 0) {
+    document.getElementById(evt.detail.xhr.getResponseHeader("x-hide-modal") + "Dismiss").click()
+  }
+})

src/MyPrayerJournal/wwwroot/style/style.css

@@ -0,0 +1,57 @@
+
+nav {
+  background-color: green;
+}
+nav .m {
+  font-weight: 100;
+}
+nav .p {
+  font-weight: 400;
+}
+nav .j {
+  font-weight: 700;
+}
+.nav-item a:link,
+.nav-item a:visited {
+  padding: .5rem 1rem;
+  margin: 0 .5rem;
+  border-radius: .5rem;
+  color: white;
+  text-decoration: none;
+}
+.nav-item a:hover {
+  cursor: pointer;
+  background-color: rgba(255, 255, 255, .2);
+}
+.nav-item a.is-active-route {
+  border-top-left-radius: 0;
+  border-top-right-radius: 0;
+  border-top: solid 4px rgba(255, 255, 255, .3);
+}
+
+form {
+  max-width: 60rem;
+  margin: auto;
+}
+.action-cell .material-icons {
+  font-size: 1.1rem ;
+}
+.material-icons {
+  vertical-align: bottom;
+}
+#toastHost {
+  position: sticky;
+  bottom: 0;
+}
+.request-text {
+  white-space: pre-line
+}
+
+footer {
+  border-top: solid 1px lightgray;
+  margin: 1rem -1rem 0;
+  padding: 0 1rem;
+}
+footer p {
+  margin: 0;
+}

src/api/app.js

@@ -1,35 +0,0 @@
-'use strict'
-
-const chalk = require('chalk')
-
-const { env } = require('./appsettings.json') // process.env.NODE_ENV || 'dev'
-
-if ('dev' === env) require('babel-register')
-const src = (env === 'dev') ? './src' : './build'
-
-const app = require(`${src}/index`).default
-const db = require(`${src}/db`).default
-
-const fullEnv = ('dev' === env) ? 'Development' : 'Production'
-
-const { port } = require('./appsettings.json')
-
-/**
- * Log a start-up message for the app
- * @param {string} status The status to display
- */
-const startupMsg = (status) => {
-  console.log(chalk`{reset myPrayerJournal ${status} | Port: {bold ${port}} | Mode: {bold ${fullEnv}}}`)
-}
-
-// Ensure the database exists before starting up
-db.verify()
-.then(() => app.listen(port, () => startupMsg('ready')))
-.catch(err => {
-  console.log(chalk`\n{reset {bgRed.white.bold ||  Error connecting to PostgreSQL  }}`)
-  for (let key of Object.keys(err)) {
-    console.log(chalk`${key}: {reset {bold ${err[key]}}}`)
-  }
-  console.log('')
-  startupMsg('failed')
-})

src/api/json.mjs

@@ -1,12 +0,0 @@
-'use strict'
-
-import fs from 'fs'
-
-/**
- * Read and parse a JSON file
- * @param {string} path The path to the file
- * @param {string} encoding The encoding of the file (defaults to UTF-8)
- * @return {*} The parsed contents of the file
- */
-export default (path, encoding = 'utf-8') =>
-  JSON.parse(fs.readFileSync(path, encoding))

src/api/package.json

@@ -1,45 +0,0 @@
-{
-  "name": "my-prayer-journal-api",
-  "private": true,
-  "version": "0.9.1",
-  "description": "Server API for myPrayerJournal",
-  "main": "index.js",
-  "author": "Daniel J. Summers <daniel@bitbadger.solutions>",
-  "license": "MIT",
-  "dependencies": {
-    "chalk": "^2.1.0",
-    "cuid": "^1.3.8",
-    "jwks-rsa-koa": "^1.1.3",
-    "koa": "^2.3.0",
-    "koa-bodyparser": "^4.2.0",
-    "koa-jwt": "^3.2.2",
-    "koa-router": "^7.2.1",
-    "koa-send": "^4.1.0",
-    "koa-static": "^4.0.1",
-    "pg": "^7.3.0"
-  },
-  "scripts": {
-    "start": "node app.js",
-    "build": "babel src -d build",
-    "vue": "cd ../app && node build/build.js prod && cd ../api && node app.js"
-  },
-  "devDependencies": {
-    "babel": "^6.23.0",
-    "babel-cli": "^6.26.0",
-    "babel-preset-env": "^1.6.0",
-    "babel-register": "^6.26.0",
-    "koa-morgan": "^1.0.1"
-  },
-  "babel": {
-    "presets": [
-      [
-        "env",
-        {
-          "targets": {
-            "node": "current"
-          }
-        }
-      ]
-    ]
-  }
-}

src/api/src/db/ddl.js

@@ -1,108 +0,0 @@
-'use strict'
-
-import { Pool } from 'pg'
-
-/**
- * SQL to check the existence of a table in the mpj schema
- * @param {string} table The name of the table whose existence should be checked
- */
-const tableSql = table => `SELECT 1 FROM pg_tables WHERE schemaname='mpj' AND tablename='${table}'`
-
-/**
- * SQL to determine if an index exists
- * @param {string} table The name of the table which the given index indexes
- * @param {string} index The name of the index
- */
-const indexSql = (table, index) =>
-  `SELECT 1 FROM pg_indexes WHERE schemaname='mpj' AND tablename='${table}' AND indexname='${index}'`
-
-const ddl = [
-  {
-    name: 'myPrayerJournal Schema',
-    check: `SELECT 1 FROM pg_namespace WHERE nspname='mpj'`,
-    fix: `
-      CREATE SCHEMA mpj;
-      COMMENT ON SCHEMA mpj IS 'myPrayerJournal data'`
-  },
-  {
-    name: 'request Table',
-    check: tableSql('request'),
-    fix: `
-      CREATE TABLE mpj.request (
-        "requestId" varchar(25) PRIMARY KEY,
-        "enteredOn" bigint NOT NULL,
-        "userId" varchar(100) NOT NULL);
-      COMMENT ON TABLE mpj.request IS 'Requests'`
-  },
-  {
-    name: 'history Table',
-    check: tableSql('history'),
-    fix: `
-      CREATE TABLE mpj.history (
-        "requestId" varchar(25) NOT NULL REFERENCES mpj.request,
-        "asOf" bigint NOT NULL,
-        "status" varchar(25),
-        "text" text,
-        PRIMARY KEY ("requestId", "asOf"));
-      COMMENT ON TABLE mpj.history IS 'Request update history'`
-  },
-  {
-    name: 'note Table',
-    check: tableSql('note'),
-    fix: `
-      CREATE TABLE mpj.note (
-        "requestId" varchar(25) NOT NULL REFERENCES mpj.request,
-        "asOf" bigint NOT NULL,
-        "notes" text NOT NULL,
-        PRIMARY KEY ("requestId", "asOf"));
-      COMMENT ON TABLE mpj.note IS 'Notes regarding a request'`
-  },
-  {
-    name: 'request.userId Index',
-    check: indexSql('request', 'idx_request_userId'),
-    fix: `
-      CREATE INDEX "idx_request_userId" ON mpj.request ("userId");
-      COMMENT ON INDEX "idx_request_userId" IS 'Requests are retrieved by user'`
-  },
-  {
-    name: 'journal View',
-    check: `SELECT 1 FROM pg_views WHERE schemaname='mpj' AND viewname='journal'`,
-    fix: `
-      CREATE VIEW mpj.journal AS
-        SELECT
-          request."requestId",
-          request."userId",
-          (SELECT "text"
-            FROM mpj.history
-            WHERE history."requestId" = request."requestId"
-              AND "text" IS NOT NULL
-            ORDER BY "asOf" DESC
-            LIMIT 1) AS "text",
-          (SELECT "asOf"
-            FROM mpj.history
-            WHERE history."requestId" = request."requestId"
-            ORDER BY "asOf" DESC
-            LIMIT 1) AS "asOf",
-          (SELECT "status"
-            FROM mpj.history
-            WHERE history."requestId" = request."requestId"
-            ORDER BY "asOf" DESC
-            LIMIT 1) AS "lastStatus"
-          FROM mpj.request;
-      COMMENT ON VIEW mpj.journal IS 'Requests with latest text'`
-  }
-]
-
-export default function (query) {
-  return {
-    /**
-     * Ensure that the database schema, tables, and indexes exist
-     */
-    ensureDatabase: async () => {
-      for (let item of ddl) {
-        const result = await query(item.check, [])
-        if (1 > result.rowCount) await query(item.fix, [])
-      }
-    }
-  }
-}

src/api/src/db/index.js

@@ -1,27 +0,0 @@
-'use strict'
-
-import { Pool, types } from 'pg'
-
-import appConfig from '../../appsettings.json'
-import ddl from './ddl'
-import request from './request'
-
-/** Pooled PostgreSQL instance */
-const pool = new Pool(appConfig.pgPool)
-
-// Return "bigint" (int8) instances as number instead of strings
-// ref: https://github.com/brianc/node-pg-types
-types.setTypeParser(20, val => parseInt(val))
-
-/**
- * Run a SQL query
- * @param {string} text The SQL command
- * @param {*[]} params The parameters for the query
- */
-const query = (text, params) => pool.query(text, params)
-
-export default {
-  query: query,
-  request: request(pool),
-  verify: ddl(query).ensureDatabase
-}

src/api/src/db/request.js

@@ -1,188 +0,0 @@
-'use strict'
-
-import { Pool } from 'pg'
-import cuid from 'cuid'
-
-const currentRequestSql = `
-  SELECT "requestId", "text", "asOf", "lastStatus"
-    FROM mpj.journal`
-
-const journalSql = `${currentRequestSql}
-  WHERE "userId" = $1
-    AND "lastStatus" <> 'Answered'`
-
-const requestNotFound = {
-  requestId: '',
-  text: 'Not Found',
-  asOf: 0
-}
-
-export default function (pool) {
-  
-  /**
-   * Retrieve basic information about a single request
-   * @param {string} requestId The Id of the request to retrieve
-   * @param {string} userId The Id of the user to whom the request belongs
-   */
-  let retrieveRequest = (requestId, userId) =>
-    pool.query(`
-      SELECT "requestId", "enteredOn"
-        FROM mpj.request
-      WHERE "requestId" = $1
-        AND "userId" = $2`,
-      [ requestId, userId ])
-  
-  return {
-    /**
-     * Add a history entry for this request
-     * @param {string} userId The Id of the user to whom this request belongs
-     * @param {string} requestId The Id of the request to which the update applies
-     * @param {string} status The status for this history entry
-     * @param {string} updateText The updated text for the request (pass blank if no update)
-     * @return {number} 404 if the request is not found or does not belong to the given user, 204 if successful
-     */
-    addHistory: async (userId, requestId, status, updateText) => {
-      const req = retrieveRequest(requestId, userId)
-      if (req.rowCount === 0) {
-        return 404
-      }
-      await pool.query(`
-        INSERT INTO mpj.history
-          ("requestId", "asOf", "status", "text")
-        VALUES
-          ($1, $2, $3, NULLIF($4, ''))`,
-        [ requestId, Date.now(), status, updateText ])
-      return 204
-    },
-
-    /**
-     * Add a new prayer request
-     * @param {string} userId The Id of the user
-     * @param {string} requestText The text of the request
-     * @return The created request
-     */
-    addNew: async (userId, requestText) => {
-      const id = cuid()
-      const enteredOn = Date.now()
-      return (async () => {
-        const client = await pool.connect()
-        try {
-          await client.query('BEGIN')
-          await client.query(
-            'INSERT INTO mpj.request ("requestId", "enteredOn", "userId") VALUES ($1, $2, $3)',
-            [ id, enteredOn, userId ])
-          await client.query(
-            `INSERT INTO mpj.history ("requestId", "asOf", "status", "text") VALUES ($1, $2, 'Created', $3)`,
-            [ id, enteredOn, requestText ])
-          await client.query('COMMIT')
-        } catch (e) {
-          await client.query('ROLLBACK')
-          throw e
-        } finally {
-          client.release()
-        }
-        return { requestId: id, text: requestText, asOf: enteredOn, lastStatus: 'Created' }
-      })().catch(e => {
-        console.error(e.stack)
-        return { requestId: '', text: 'error', asOf: 0, lastStatus: 'Errored' }
-      })
-    },
-
-    /**
-     * Add a note about a prayer request
-     * @param {string} userId The Id of the user to whom the request belongs
-     * @param {string} requestId The Id of the request to which the note applies
-     * @param {string} note The notes to add
-     * @return {number} 404 if the request is not found or does not belong to the given user, 204 if successful
-     */
-    addNote: async (userId, requestId, note) => {
-      const req = retrieveRequest(requestId, userId)
-      if (req.rowCount === 0) {
-        return 404
-      }
-      await pool.query(`
-        INSERT INTO mpj.note
-          ("requestId", "asOf", "notes")
-        VALUES
-          ($1, $2, $3)`,
-        [ requestId, Date.now(), note ])
-      return 204
-    },
-
-    /**
-     * Get all answered requests with their text as of the "Answered" status
-     * @param {string} userId The Id of the user for whom requests should be retrieved
-     * @return All requests
-     */
-    answered: async (userId) => 
-      (await pool.query(`${currentRequestSql}
-        WHERE "userId" = $1
-          AND "lastStatus" = 'Answered'
-        ORDER BY "asOf" DESC`,
-        [ userId ])).rows,
-
-    /**
-     * Get the "current" version of a request by its Id
-     * @param {string} requestId The Id of the request to retrieve
-     * @param {string} userId The Id of the user to which the request belongs
-     * @return The request, or a request-like object indicating that the request was not found
-     */
-    byId: async (userId, requestId) => {
-      const reqs = await pool.query(`${currentRequestSql}
-        WHERE "requestId" = $1
-          AND "userId" = $2`,
-        [ requestId, userId ])
-      return (0 < reqs.rowCount) ? reqs.rows[0] : requestNotFound
-    },
-
-    /**
-     * Get a prayer request, including its full history, by its Id
-     * @param {string} userId The Id of the user to which the request belongs
-     * @param {string} requestId The Id of the request to retrieve
-     * @return The request, or a request-like object indicating that the request was not found
-     */
-    fullById: async (userId, requestId) => {
-      const reqResults = await retrieveRequest(requestId, userId)
-      if (0 === reqResults.rowCount) {
-        return requestNotFound
-      }
-      const req = reqResults.rows[0]
-      const history = await pool.query(`
-        SELECT "asOf", "status", COALESCE("text", '') AS "text"
-          FROM mpj.history
-         WHERE "requestId" = $1
-         ORDER BY "asOf"`,
-        [ requestId ])
-      req.history = history.rows
-      return req
-    },
-
-    /**
-     * Get the current requests for a user (i.e., their complete current journal)
-     * @param {string} userId The Id of the user
-     * @return The requests that make up the current journal
-     */
-    journal: async userId => (await pool.query(`${journalSql} ORDER BY "asOf"`, [ userId ])).rows,
-
-    /**
-     * Get the notes for a request, most recent first
-     * @param {string} userId The Id of the user to whom the request belongs
-     * @param {string} requestId The Id of the request whose notes should be retrieved
-     * @return The notes for the request
-     */
-    notesById: async (userId, requestId) => {
-      const reqResults = await retrieveRequest(requestId, userId)
-      if (0 === reqResults.rowCount) {
-        return requestNotFound
-      }
-      const notes = await pool.query(`
-        SELECT "asOf", "notes"
-          FROM mpj.note
-         WHERE "requestId" = $1
-         ORDER BY "asOf" DESC`,
-        [ requestId ])
-      return notes.rows
-    }
-    
-  }
-}

src/api/src/index.js

@@ -1,36 +0,0 @@
-'use strict'
-
-import Koa from 'koa'
-import bodyParser from 'koa-bodyparser'
-import morgan from 'koa-morgan'
-import send from 'koa-send'
-import serveFrom from 'koa-static'
-
-import appConfig from '../appsettings.json'
-import router from './routes'
-
-/** Koa app */
-const app = new Koa()
-
-if (appConfig.env === 'dev') app.use(morgan('dev'))
-
-export default app
-  // Serve the Vue files from /public
-  .use(serveFrom('public'))
-  // Parse the body into ctx.request.body, if present
-  .use(bodyParser())
-  // Tie in all the routes
-  .use(router.routes())
-  .use(router.allowedMethods())
-  // Send the index.html file for what would normally get a 404
-  .use(async (ctx, next) => {
-    if (ctx.url.indexOf('/api') === -1) {
-      try {
-        await send(ctx, 'index.html', { root: __dirname + '/../public/' })
-      }
-      catch (err) {
-        return await next(err)
-      }
-    }
-    return await next()
-  })

src/api/src/routes/index.js

@@ -1,39 +0,0 @@
-'use strict'
-
-import jwt from 'koa-jwt'
-import jwksRsa from 'jwks-rsa-koa'
-import Router from 'koa-router'
-
-import appConfig from '../../appsettings.json'
-import journal from './journal'
-import request from './request'
-
-/** Authentication middleware to verify the access token against the Auth0 JSON Web Key Set */
-const checkJwt = jwt({
-  // Dynamically provide a signing key
-  // based on the kid in the header and 
-  // the singing keys provided by the JWKS endpoint.
-  secret: jwksRsa.koaJwt2Key({
-    cache: true,
-    rateLimit: true,
-    jwksRequestsPerMinute: 5,
-    jwksUri: `https://${appConfig.auth0.domain}/.well-known/jwks.json`
-  }),
-
-  // Validate the audience and the issuer.
-  audience: appConfig.auth0.clientId,
-  issuer: `https://${appConfig.auth0.domain}/`,
-  algorithms: ['RS256']
-})
-
-/** /api/journal routes */
-const journalRoutes = journal(checkJwt)
-/** /api/request routes */
-const requestRoutes = request(checkJwt)
-
-/** Combined router */
-const router = new Router({ prefix: '/api' })
-router.use('/journal', journalRoutes.routes(), journalRoutes.allowedMethods())
-router.use('/request', requestRoutes.routes(), requestRoutes.allowedMethods())
-
-export default router

src/api/src/routes/journal.js

@@ -1,16 +0,0 @@
-'use strict'
-
-import Router from 'koa-router'
-import db from '../db'
-
-const router = new Router()
-
-export default function (checkJwt) {
-
-  router.get('/', checkJwt, async (ctx, next) => {
-    const reqs = await db.request.journal(ctx.state.user.sub)
-    ctx.body = reqs
-    return await next()
-  })
-  return router
-}

src/api/src/routes/request.js

@@ -1,79 +0,0 @@
-'use strict'
-
-import Router from 'koa-router'
-import db from '../db'
-
-const router = new Router()
-
-export default function (checkJwt) {
-
-  router
-    // Add a new request
-    .post('/', checkJwt, async (ctx, next) => {
-      ctx.body = await db.request.addNew(ctx.state.user.sub, ctx.request.body.requestText)
-      await next()
-    })
-    // Add a request history entry (prayed, updated, answered, etc.)
-    .post('/:id/history', checkJwt, async (ctx, next) => {
-      const body = ctx.request.body
-      ctx.response.status = await db.request.addHistory(ctx.state.user.sub, ctx.params.id, body.status, body.updateText)
-      await next()
-    })
-    // Add a note to a request
-    .post('/:id/note', checkJwt, async (ctx, next) => {
-      const body = ctx.request.body
-      ctx.response.status = await db.request.addNote(ctx.state.user.sub, ctx.params.id, body.notes)
-      await next()
-    })
-    // Get a journal-style request by its Id
-    .get('/:id', checkJwt, async (ctx, next) => {
-      const req = await db.request.byId(ctx.state.user.sub, ctx.params.id)
-      if ('Not Found' === req.text) {
-        ctx.response.status = 404
-      } else {
-        ctx.body = req
-      }
-      await next()
-    })
-    // Get a request, along with its full history
-    .get('/:id/full', checkJwt, async (ctx, next) => {
-      const req = await db.request.fullById(ctx.state.user.sub, ctx.params.id)
-      if ('Not Found' === req.text) {
-        ctx.response.status = 404
-      } else {
-        ctx.body = req
-      }
-      await next()
-    })
-    // Get the notes for a request
-    .get('/:id/notes', checkJwt, async (ctx, next) => {
-      const notes = await db.request.notesById(ctx.state.user.sub, ctx.params.id)
-      if (notes.text && 'Not Found' === notes.text) {
-        ctx.response.status = 404
-      } else {
-        ctx.body = notes
-        ctx.response.status = 200
-      }
-      await next()
-    })
-    // Get a complete request; equivalent to full + notes
-    .get('/:id/complete', checkJwt, async (ctx, next) => {
-      const req = await db.request.fullById(ctx.state.user.sub, ctx.params.id)
-      if ('Not Found' === req.text) {
-        ctx.response.status = 404
-      } else {
-        ctx.response.status = 200
-        req.notes = await db.request.notesById(ctx.state.user.sub, ctx.params.id)
-        ctx.body = req
-      }
-      await next()
-    })
-    // Get all answered requests
-    .get('/answered', checkJwt, async (ctx, next) => {
-      ctx.body = await db.request.answered(ctx.state.user.sub)
-      ctx.response.status = 200
-      await next()
-    })
-
-  return router
-}

src/app/.babelrc

@@ -1,18 +0,0 @@
-{
-  "presets": [
-    ["env", {
-      "modules": false,
-      "targets": {
-        "browsers": ["> 1%", "last 2 versions", "not ie <= 8"]
-      }
-    }],
-    "stage-2"
-  ],
-  "plugins": ["transform-runtime"],
-  "env": {
-    "test": {
-      "presets": ["env", "stage-2"],
-      "plugins": ["istanbul"]
-    }
-  }
-}

src/app/.editorconfig

@@ -1,9 +0,0 @@
-root = true
-
-[*]
-charset = utf-8
-indent_style = space
-indent_size = 2
-end_of_line = lf
-insert_final_newline = true
-trim_trailing_whitespace = true

src/app/.eslintignore

@@ -1,2 +0,0 @@
-build/*.js
-config/*.js

src/app/.eslintrc.js

@@ -1,27 +0,0 @@
-// http://eslint.org/docs/user-guide/configuring
-
-module.exports = {
-  root: true,
-  parser: 'babel-eslint',
-  parserOptions: {
-    sourceType: 'module'
-  },
-  env: {
-    browser: true,
-  },
-  // https://github.com/feross/standard/blob/master/RULES.md#javascript-standard-style
-  extends: 'standard',
-  // required to lint *.vue files
-  plugins: [
-    'html'
-  ],
-  // add your custom rules here
-  'rules': {
-    // allow paren-less arrow functions
-    'arrow-parens': 0,
-    // allow async-await
-    'generator-star-spacing': 0,
-    // allow debugger during development
-    'no-debugger': process.env.NODE_ENV === 'production' ? 2 : 0
-  }
-}

src/app/.gitignore

@@ -1,19 +0,0 @@
-.DS_Store
-node_modules/
-dist/
-npm-debug.log*
-yarn-debug.log*
-yarn-error.log*
-test/unit/coverage
-test/e2e/reports
-selenium-debug.log
-
-# Editor directories and files
-.idea
-*.suo
-*.ntvs*
-*.njsproj
-*.sln
-
-# Auth0 settings
-src/auth/auth0-variables.js

src/app/.postcssrc.js

@@ -1,8 +0,0 @@
-// https://github.com/michael-ciniawsky/postcss-load-config
-
-module.exports = {
-  "plugins": {
-    // to edit target browsers: use "browserslist" field in package.json
-    "autoprefixer": {}
-  }
-}

src/app/LICENSE

@@ -1,21 +0,0 @@
-MIT License
-
-Copyright (c) 2017 Daniel J. Summers
-
-Permission is hereby granted, free of charge, to any person obtaining a copy
-of this software and associated documentation files (the "Software"), to deal
-in the Software without restriction, including without limitation the rights
-to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
-copies of the Software, and to permit persons to whom the Software is
-furnished to do so, subject to the following conditions:
-
-The above copyright notice and this permission notice shall be included in all
-copies or substantial portions of the Software.
-
-THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
-IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
-FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
-AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
-LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
-OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
-SOFTWARE.

src/app/config/dev.env.js

@@ -1,6 +0,0 @@
-var merge = require('webpack-merge')
-var prodEnv = require('./prod.env')
-
-module.exports = merge(prodEnv, {
-  NODE_ENV: '"development"'
-})

src/app/config/index.js

@@ -1,38 +0,0 @@
-// see http://vuejs-templates.github.io/webpack for documentation.
-var path = require('path')
-
-module.exports = {
-  build: {
-    env: require('./prod.env'),
-    index: path.resolve(__dirname, '../../api/public/index.html'),
-    assetsRoot: path.resolve(__dirname, '../../api/public'),
-    assetsSubDirectory: 'static',
-    assetsPublicPath: '/',
-    productionSourceMap: true,
-    // Gzip off by default as many popular static hosts such as
-    // Surge or Netlify already gzip all static assets for you.
-    // Before setting to `true`, make sure to:
-    // npm install --save-dev compression-webpack-plugin
-    productionGzip: false,
-    productionGzipExtensions: ['js', 'css'],
-    // Run the build command with an extra argument to
-    // View the bundle analyzer report after build finishes:
-    // `npm run build --report`
-    // Set to `true` or `false` to always turn it on or off
-    bundleAnalyzerReport: process.env.npm_config_report
-  },
-  dev: {
-    env: require('./dev.env'),
-    port: 8080,
-    autoOpenBrowser: true,
-    assetsSubDirectory: 'static',
-    assetsPublicPath: '/',
-    proxyTable: {},
-    // CSS Sourcemaps off by default because relative paths are "buggy"
-    // with this option, according to the CSS-Loader README
-    // (https://github.com/webpack/css-loader#sourcemaps)
-    // In our experience, they generally work as expected,
-    // just be aware of this issue when enabling this option.
-    cssSourceMap: false
-  }
-}

src/app/config/prod.env.js

@@ -1,3 +0,0 @@
-module.exports = {
-  NODE_ENV: '"production"'
-}

src/app/config/test.env.js

@@ -1,6 +0,0 @@
-var merge = require('webpack-merge')
-var devEnv = require('./dev.env')
-
-module.exports = merge(devEnv, {
-  NODE_ENV: '"testing"'
-})

src/app/index.html

@@ -1,13 +0,0 @@
-<!DOCTYPE html>
-<html>
-  <head>
-    <meta charset="utf-8">
-    <meta name="viewport" content="width=device-width, initial-scale=1">
-    <title>myPrayerJournal</title>
-    <link rel="stylesheet" href="https://fonts.googleapis.com/icon?family=Material+Icons">
-  </head>
-  <body>
-    <div id="app"></div>
-    <!-- built files will be auto injected -->
-  </body>
-</html>

src/app/package.json

@@ -1,104 +0,0 @@
-{
-  "name": "my-prayer-journal",
-  "version": "0.9.1",
-  "description": "myPrayerJournal - Front End",
-  "author": "Daniel J. Summers <daniel@bitbadger.solutions>",
-  "private": true,
-  "scripts": {
-    "dev": "node build/dev-server.js",
-    "start": "node build/dev-server.js",
-    "build": "node build/build.js",
-    "unit": "cross-env BABEL_ENV=test karma start test/unit/karma.conf.js --single-run",
-    "e2e": "node test/e2e/runner.js",
-    "test": "npm run unit && npm run e2e",
-    "lint": "eslint --ext .js,.vue src test/unit/specs test/e2e/specs"
-  },
-  "dependencies": {
-    "auth0-js": "^8.10.1",
-    "axios": "^0.16.2",
-    "bootstrap-vue": "^1.0.0-beta.9",
-    "moment": "^2.18.1",
-    "pug": "^2.0.0-rc.4",
-    "vue": "^2.4.4",
-    "vue-awesome": "^2.3.3",
-    "vue-progressbar": "^0.7.3",
-    "vue-router": "^2.6.0",
-    "vue-toast": "^3.1.0",
-    "vuex": "^2.4.0"
-  },
-  "devDependencies": {
-    "autoprefixer": "^7.1.4",
-    "babel-core": "^6.26.0",
-    "babel-eslint": "^7.1.1",
-    "babel-loader": "^7.1.2",
-    "babel-plugin-istanbul": "^4.1.5",
-    "babel-plugin-transform-runtime": "^6.22.0",
-    "babel-preset-env": "^1.3.2",
-    "babel-preset-stage-2": "^6.22.0",
-    "babel-register": "^6.26.0",
-    "chai": "^3.5.0",
-    "chalk": "^2.1.0",
-    "chromedriver": "^2.32.3",
-    "connect-history-api-fallback": "^1.3.0",
-    "copy-webpack-plugin": "^4.0.1",
-    "cross-env": "^5.0.5",
-    "cross-spawn": "^5.0.1",
-    "css-loader": "^0.28.7",
-    "cssnano": "^3.10.0",
-    "eslint": "^3.19.0",
-    "eslint-config-standard": "^6.2.1",
-    "eslint-friendly-formatter": "^3.0.0",
-    "eslint-loader": "^1.7.1",
-    "eslint-plugin-html": "^3.2.2",
-    "eslint-plugin-promise": "^3.4.0",
-    "eslint-plugin-standard": "^2.0.1",
-    "eventsource-polyfill": "^0.9.6",
-    "express": "^4.15.4",
-    "extract-text-webpack-plugin": "^2.0.0",
-    "file-loader": "^0.11.1",
-    "friendly-errors-webpack-plugin": "^1.1.3",
-    "html-webpack-plugin": "^2.30.1",
-    "http-proxy-middleware": "^0.17.3",
-    "inject-loader": "^3.0.1",
-    "karma": "^1.7.1",
-    "karma-coverage": "^1.1.1",
-    "karma-mocha": "^1.3.0",
-    "karma-phantomjs-launcher": "^1.0.2",
-    "karma-phantomjs-shim": "^1.4.0",
-    "karma-sinon-chai": "^1.3.2",
-    "karma-sourcemap-loader": "^0.3.7",
-    "karma-spec-reporter": "0.0.31",
-    "karma-webpack": "^2.0.2",
-    "lolex": "^1.5.2",
-    "mocha": "^3.5.3",
-    "nightwatch": "^0.9.12",
-    "opn": "^5.1.0",
-    "optimize-css-assets-webpack-plugin": "^2.0.0",
-    "ora": "^1.2.0",
-    "phantomjs-prebuilt": "^2.1.15",
-    "rimraf": "^2.6.2",
-    "selenium-server": "^3.5.3",
-    "semver": "^5.4.1",
-    "shelljs": "^0.7.6",
-    "sinon": "^2.4.1",
-    "sinon-chai": "^2.13.0",
-    "url-loader": "^0.5.8",
-    "vue-loader": "^12.1.0",
-    "vue-style-loader": "^3.0.3",
-    "vue-template-compiler": "^2.4.4",
-    "webpack": "^2.6.1",
-    "webpack-bundle-analyzer": "^2.9.0",
-    "webpack-dev-middleware": "^1.12.0",
-    "webpack-hot-middleware": "^2.19.1",
-    "webpack-merge": "^4.1.0"
-  },
-  "engines": {
-    "node": ">= 4.0.0",
-    "npm": ">= 3.0.0"
-  },
-  "browserslist": [
-    "> 1%",
-    "last 2 versions",
-    "not ie <= 8"
-  ]
-}

src/app/src/App.vue

@@ -1,70 +0,0 @@
-<template lang="pug">
-#app
-  navigation
-  #content.container
-    router-view
-    vue-progress-bar
-    toast(ref='toast')
-  footer
-    p.text-right.text-muted
-      | myPrayerJournal v{{ version }}
-      br
-      em: small.
-        #[a(href='https://github.com/danieljsummers/myprayerjournal') Developed] and hosted by
-        #[a(href='https://bitbadger.solutions') Bit Badger Solutions]
-</template>
-
-<script>
-'use strict'
-
-import Navigation from './components/Navigation.vue'
-
-import { version } from '../package.json'
-
-export default {
-  name: 'app',
-  components: {
-    Navigation
-  },
-  data () {
-    return { version }
-  },
-  mounted () {
-    this.$refs.toast.setOptions({ position: 'bottom right' })
-  },
-  computed: {
-    toast () {
-      return this.$refs.toast
-    }
-  }
-}
-</script>
-
-<style>
-html, body {
-  background-color: whitesmoke;
-}
-body {
-  padding-top: 60px;
-}
-footer {
-  border-top: solid 1px lightgray;
-  margin-top: 1rem;
-  padding: 0 1rem;
-}
-footer p {
-  margin: 0;
-}
-a:link, a:visited {
-  color: #050;
-}
-.mpj-request-text {
-  white-space: pre-line;
-}
-.bg-mpj {
-  background-image: -webkit-gradient(linear, left top, left bottom, from(#050), to(whitesmoke));
-  background-image: -webkit-linear-gradient(top, #050, whitesmoke);
-  background-image: -moz-linear-gradient(top, #050, whitesmoke);
-  background-image: linear-gradient(to bottom, #050, whitesmoke);
-}
-</style>

src/app/src/api/index.js

@@ -1,78 +0,0 @@
-import axios from 'axios'
-
-const http = axios.create({
-  baseURL: `${location.protocol}//${location.host}/api/`
-})
-
-/**
- * API access for myPrayerJournal
- */
-export default {
-
-  /**
-   * Set the bearer token for all future requests
-   * @param {string} token The token to use to identify the user to the server
-   */
-  setBearer: token => { http.defaults.headers.common['authorization'] = `Bearer ${token}` },
-
-  /**
-   * Remove the bearer token
-   */
-  removeBearer: () => delete http.defaults.headers.common['authorization'],
-
-  /**
-   * Add a note for a prayer request
-   * @param {string} requestId The Id of the request to which the note applies
-   * @param {string} notes The notes to be added
-   */
-  addNote: (requestId, notes) => http.post(`request/${requestId}/note`, { notes }),
-
-  /**
-   * Add a new prayer request
-   * @param {string} requestText The text of the request to be added
-   */
-  addRequest: requestText => http.post('request/', { requestText }),
-
-  /**
-   * Get all answered requests, along with the text they had when it was answered
-   */
-  getAnsweredRequests: () => http.get('request/answered'),
-
-  /**
-   * Get a prayer request (full; includes all history)
-   * @param {string} requestId The Id of the request to retrieve
-   */
-  getFullRequest: requestId => http.get(`request/${requestId}/full`),
-
-  /**
-   * Get past notes for a prayer request
-   * @param {string} requestId The Id of the request for which notes should be retrieved
-   */
-  getNotes: requestId => http.get(`request/${requestId}/notes`),
-
-  /**
-   * Get a prayer request (journal-style; only latest update)
-   * @param {string} requestId The Id of the request to retrieve
-   */
-  getRequest: requestId => http.get(`request/${requestId}`),
-
-  /**
-   * Get a complete request; equivalent of "full" and "notes" combined
-   */
-  getRequestComplete: requestId => http.get(`request/${requestId}/complete`),
-
-  /**
-   * Get all prayer requests and their most recent updates
-   */
-  journal: () => http.get('journal/'),
-
-  /**
-   * Update a prayer request
-   * @param request The request (should have requestId, status, and updateText properties)
-   */
-  updateRequest: request => http.post(`request/${request.requestId}/history`, {
-    status: request.status,
-    updateText: request.updateText
-  })
-
-}

src/app/src/auth/AuthService.js

@@ -1,139 +0,0 @@
-'use strict'
-
-import auth0 from 'auth0-js'
-
-import AUTH_CONFIG from './auth0-variables'
-import mutations from '@/store/mutation-types'
-
-var tokenRenewalTimeout
-
-export default class AuthService {
-
-  constructor () {
-    this.login = this.login.bind(this)
-    this.setSession = this.setSession.bind(this)
-    this.logout = this.logout.bind(this)
-    this.isAuthenticated = this.isAuthenticated.bind(this)
-  }
-
-  auth0 = new auth0.WebAuth({
-    domain: AUTH_CONFIG.domain,
-    clientID: AUTH_CONFIG.clientId,
-    redirectUri: AUTH_CONFIG.appDomain + AUTH_CONFIG.callbackUrl,
-    audience: `https://${AUTH_CONFIG.domain}/userinfo`,
-    responseType: 'token id_token',
-    scope: 'openid profile email'
-  })
-
-  login () {
-    this.auth0.authorize()
-  }
-
-  /**
-   * Promisified parseHash function
-   */
-  parseHash () {
-    return new Promise((resolve, reject) => {
-      this.auth0.parseHash((err, authResult) => {
-        if (err) {
-          reject(err)
-        } else {
-          resolve(authResult)
-        }
-      })
-    })
-  }
-
-  /**
-   * Promisified userInfo function
-   *
-   * @param token The auth token from the login result
-   */
-  userInfo (token) {
-    return new Promise((resolve, reject) => {
-      this.auth0.client.userInfo(token, (err, user) => {
-        if (err) {
-          reject(err)
-        } else {
-          resolve(user)
-        }
-      })
-    })
-  }
-
-  handleAuthentication (store, router) {
-    this.parseHash()
-      .then(authResult => {
-        if (authResult && authResult.accessToken && authResult.idToken) {
-          this.setSession(authResult)
-          this.userInfo(authResult.accessToken)
-            .then(user => {
-              store.commit(mutations.USER_LOGGED_ON, user)
-              router.replace('/journal')
-            })
-        }
-      })
-      .catch(err => {
-        router.replace('/')
-        console.log(err)
-        alert(`Error: ${err.error}. Check the console for further details.`)
-      })
-  }
-
-  scheduleRenewal () {
-    let expiresAt = JSON.parse(localStorage.getItem('expires_at'))
-    let delay = expiresAt - Date.now()
-    if (delay > 0) {
-      tokenRenewalTimeout = setTimeout(() => {
-        this.renewToken()
-      }, delay)
-    }
-  }
-
-  setSession (authResult) {
-    // Set the time that the access token will expire at
-    let expiresAt = JSON.stringify(
-      authResult.expiresIn * 1000 + new Date().getTime()
-    )
-    localStorage.setItem('access_token', authResult.accessToken)
-    localStorage.setItem('id_token', authResult.idToken)
-    localStorage.setItem('expires_at', expiresAt)
-    this.scheduleRenewal()
-  }
-
-  renewToken () {
-    console.log('attempting renewal...')
-    this.auth0.renewAuth(
-      {
-        audience: `https://${AUTH_CONFIG.domain}/userinfo`,
-        redirectUri: `${AUTH_CONFIG.appDomain}/static/silent.html`,
-        usePostMessage: true
-      },
-      (err, result) => {
-        if (err) {
-          console.log(err)
-        } else {
-          this.setSession(result)
-        }
-      }
-    )
-  }
-
-  logout (store, router) {
-    // Clear access token and ID token from local storage
-    clearTimeout(tokenRenewalTimeout)
-    localStorage.removeItem('access_token')
-    localStorage.removeItem('id_token')
-    localStorage.removeItem('expires_at')
-    localStorage.setItem('user_profile', JSON.stringify({}))
-    // navigate to the home route
-    store.commit(mutations.USER_LOGGED_OFF)
-    router.replace('/')
-  }
-
-  isAuthenticated () {
-    // Check whether the current time is past the access token's expiry time
-    let expiresAt = JSON.parse(localStorage.getItem('expires_at'))
-    return new Date().getTime() < expiresAt
-  }
-}

src/app/src/components/Answered.vue

@@ -1,61 +0,0 @@
-<template lang="pug">
-article
-  page-title(title='Answered Requests')
-  p(v-if='!loaded') Loading answered requests...
-  div(v-if='loaded').mpj-answered-list
-    p.mpj-request-text(v-for='req in requests' :key='req.requestId')
-      | {{ req.text }}
-      br
-      br
-      b-btn(:to='{ name: "AnsweredDetail", params: { id: req.requestId }}'
-            size='sm'
-            variant='outline-secondary')
-        icon(name='search')
-        = ' View Full Request'
-      small.text-muted: em.
-        &nbsp; Answered #[date-from-now(:value='req.asOf')]
-</template>
-
-<script>
-'use static'
-
-import api from '@/api'
-
-export default {
-  name: 'answered',
-  data () {
-    return {
-      requests: [],
-      loaded: false
-    }
-  },
-  computed: {
-    toast () {
-      return this.$parent.$refs.toast
-    }
-  },
-  async mounted () {
-    this.$Progress.start()
-    try {
-      const reqs = await api.getAnsweredRequests()
-      this.requests = reqs.data
-      this.$Progress.finish()
-    } catch (err) {
-      console.error(err)
-      this.toast.showToast('Error loading requests; check console for details', { theme: 'danger' })
-      this.$Progress.fail()
-    } finally {
-      this.loaded = true
-    }
-  }
-}
-</script>
-
-<style>
-.mpj-answered-list p {
-  border-top: solid 1px lightgray;
-}
-.mpj-answered-list p:first-child {
-  border-top: none;
-}
-</style>

src/app/src/components/AnsweredDetail.vue

@@ -1,82 +0,0 @@
-<template lang="pug">
-article
-  page-title(title='Answered Request')
-  p(v-if='!request') Loading request...
-  template(v-if='request')
-    p.
-      Answered {{ formatDate(answered) }} (#[date-from-now(:value='answered')]) &nbsp;
-      #[small: em.text-muted prayed {{ prayedCount }} times, open {{ openDays }} days]
-    p.mpj-request-text {{ lastText }}
-    b-table(small hover :fields='fields' :items='log')
-      template(slot='action' scope='data').
-        {{ data.item.status }} on #[span.text-nowrap {{ formatDate(data.item.asOf) }}]
-</template>
-
-<script>
-'use strict'
-
-import moment from 'moment'
-
-import api from '@/api'
-
-const asOfDesc = (a, b) => b.asOf - a.asOf
-
-export default {
-  name: 'answer-detail',
-  props: {
-    id: {
-      type: String,
-      required: true
-    }
-  },
-  data () {
-    return {
-      request: null,
-      fields: [
-        { key: 'action', label: 'Action' },
-        { key: 'text', label: 'Update / Notes' }
-      ]
-    }
-  },
-  computed: {
-    answered () {
-      return this.request.history.find(hist => hist.status === 'Answered').asOf
-    },
-    lastText () {
-      return this.request.history
-        .filter(hist => hist.text > '')
-        .sort(asOfDesc)[0].text
-    },
-    log () {
-      return this.request.notes
-        .map(note => ({ asOf: note.asOf, text: note.notes, status: 'Notes' }))
-        .concat(this.request.history)
-        .sort(asOfDesc)
-        .slice(1)
-    },
-    openDays () {
-      return Math.floor(
-        (this.answered - this.request.history.find(hist => hist.status === 'Created').asOf) / 1000 / 60 / 60 / 24)
-    },
-    prayedCount () {
-      return this.request.history.filter(hist => hist.status === 'Prayed').length
-    }
-  },
-  async mounted () {
-    this.$Progress.start()
-    try {
-      const req = await api.getRequestComplete(this.id)
-      this.request = req.data
-      this.$Progress.finish()
-    } catch (e) {
-      console.log(e)
-      this.$Progress.fail()
-    }
-  },
-  methods: {
-    formatDate (asOf) {
-      return moment(asOf).format('LL')
-    }
-  }
-}
-</script>

src/app/src/components/Home.vue

@@ -1,22 +0,0 @@
-<template lang="pug">
-article
-  page-title(title='Welcome!'
-             hideOnPage='true')
-  p &nbsp;
-  p.
-    myPrayerJournal is a place where individuals can record their prayer requests, record that they prayed for them,
-    update them as God moves in the situation, and record a final answer received on that request. It will also allow
-    individuals to review their answered prayers.
-  p.
-    This site is currently in beta, but it is open and available to the general public. To get started, simply click
-    the "Log On" link above, and log on with either a Microsoft or Google account. You can also learn more about the
-    site at the "Docs" link, also above.
-</template>
-
-<script>
-'use strict'
-
-export default {
-  name: 'home'
-}
-</script>

src/app/src/components/Journal.vue

@@ -1,68 +0,0 @@
-<template lang="pug">
-article
-  page-title(:title='title')
-  p(v-if='isLoadingJournal') Loading your prayer journal...
-  template(v-if='!isLoadingJournal')
-    new-request
-    br
-    b-row(v-if='journal.length > 0')
-      request-card(v-for='request in journal'
-                   :key='request.requestId'
-                   :request='request'
-                   :events='eventBus'
-                   :toast='toast')
-    p.text-center(v-if='journal.length === 0'): em No requests found; click the "Add a New Request" button to add one
-    edit-request(:events='eventBus'
-                 :toast='toast')
-    notes-edit(:events='eventBus'
-               :toast='toast')
-    full-request(:events='eventBus')
-</template>
-
-<script>
-'use strict'
-
-import Vue from 'vue'
-import { mapState } from 'vuex'
-import chunk from 'lodash/chunk'
-
-import EditRequest from './request/EditRequest'
-import FullRequest from './request/FullRequest'
-import NewRequest from './request/NewRequest'
-import NotesEdit from './request/NotesEdit'
-import RequestCard from './request/RequestCard'
-
-import actions from '@/store/action-types'
-
-export default {
-  name: 'journal',
-  components: {
-    EditRequest,
-    FullRequest,
-    NewRequest,
-    NotesEdit,
-    RequestCard
-  },
-  data () {
-    return {
-      eventBus: new Vue()
-    }
-  },
-  computed: {
-    title () {
-      return `${this.user.given_name}'s Prayer Journal`
-    },
-    journalCardRows () {
-      return chunk(this.journal, 3)
-    },
-    toast () {
-      return this.$parent.$refs.toast
-    },
-    ...mapState(['user', 'journal', 'isLoadingJournal'])
-  },
-  async created () {
-    await this.$store.dispatch(actions.LOAD_JOURNAL, this.$Progress)
-    this.toast.showToast(`Loaded ${this.journal.length} prayer requests`, { theme: 'success' })
-  }
-}
-</script>

src/app/src/components/Navigation.vue

@@ -1,49 +0,0 @@
-<template lang="pug">
-b-navbar(toggleable='sm'
-         type='dark'
-         variant='mpj'
-         fixed='top')
-  b-nav-toggle(target='nav_collapse')
-  b-navbar-brand(to='/')
-    span(style='font-weight:100;') my
-    span(style='font-weight:600;') Prayer
-    span(style='font-weight:700;') Journal
-  b-collapse#nav_collapse(is-nav)
-    b-nav(is-nav-bar)
-      b-nav-item(v-if='isAuthenticated'
-                 to='/journal') Journal
-      b-nav-item(v-if='isAuthenticated'
-                 to='/answered') Answered
-      b-nav-item(v-if='isAuthenticated'): a(@click.stop='logOff()') Log Off
-      b-nav-item(v-if='!isAuthenticated'): a(@click.stop='logOn()') Log On
-      b-nav-item(href='https://danieljsummers.github.io/myPrayerJournal/'
-                 target='_blank'
-                 @click.stop='') Docs
-</template>
-
-<script>
-'use strict'
-
-import { mapState } from 'vuex'
-import AuthService from '@/auth/AuthService'
-
-export default {
-  name: 'navigation',
-  data () {
-    return {
-      auth0: new AuthService()
-    }
-  },
-  computed: {
-    ...mapState([ 'isAuthenticated' ])
-  },
-  methods: {
-    logOn () {
-      this.auth0.login()
-    },
-    logOff () {
-      this.auth0.logout(this.$store, this.$router)
-    }
-  }
-}
-</script>

src/app/src/components/common/DateFromNow.vue

@@ -1,52 +0,0 @@
-<script>
-'use strict'
-
-import moment from 'moment'
-
-export default {
-  name: 'date-from-now',
-  props: {
-    tag: {
-      type: String,
-      default: 'span'
-    },
-    value: {
-      type: Number,
-      default: 0
-    },
-    interval: {
-      type: Number,
-      default: 10000
-    }
-  },
-  data () {
-    const dt = moment(this.value)
-    return {
-      fromNow: dt.fromNow(),
-      actual: dt.format('LLLL'),
-      intervalId: null
-    }
-  },
-  mounted () {
-    this.intervalId = setInterval(this.updateFromNow, this.interval)
-    this.$watch('value', this.updateFromNow)
-  },
-  beforeDestroy () {
-    clearInterval(this.intervalId)
-  },
-  methods: {
-    updateFromNow () {
-      let newFromNow = moment(this.value).fromNow()
-      if (newFromNow !== this.fromNow) this.fromNow = newFromNow
-    }
-  },
-  render (createElement) {
-    return createElement(this.tag, {
-      domProps: {
-        title: this.actual,
-        innerText: this.fromNow
-      }
-    })
-  }
-}
-</script>

src/app/src/components/common/PageTitle.vue

@@ -1,35 +0,0 @@
-<template lang="pug">
-h2.mpj-page-title(v-if='!hideOnPage'
-                  v-html='title')
-</template>
-
-<script>
-export default {
-  name: 'page-title',
-  props: {
-    title: {
-      type: String,
-      required: true
-    },
-    hideOnPage: {
-      type: Boolean,
-      default: false
-    }
-  },
-  watch: {
-    title () {
-      document.title = `${this.title} « myPrayerJournal`
-    }
-  },
-  created () {
-    document.title = `${this.title} « myPrayerJournal`
-  }
-}
-</script>
-
-<style scoped>
-.mpj-page-title {
-  border-bottom: solid 1px lightgray;
-  margin-bottom: 20px;
-}
-</style>

src/app/src/components/request/EditRequest.vue

@@ -1,89 +0,0 @@
-<template lang="pug">
-b-modal(v-model='editVisible'
-        header-bg-variant='mpj'
-        header-text-variant='light'
-        size='lg'
-        title='Edit Prayer Request'
-        @edit='openDialog()'
-        @shows='focusRequestText')
-  b-form
-    b-form-group(label='Prayer Request'
-                 label-for='request_text')
-      b-textarea#request_text(ref='toFocus'
-                              v-model='form.requestText'
-                              :rows='10'
-                              @blur='trimText()')
-    b-form-group(label='Also Mark As')
-      b-radio-group(v-model='form.status'
-                    buttons)
-        b-radio(value='Updated') Updated
-        b-radio(value='Prayed') Prayed
-        b-radio(value='Answered') Answered
-  div.w-100.text-right(slot='modal-footer')
-    b-btn(variant='primary'
-          @click='saveRequest()') Save
-    | &nbsp; &nbsp;
-    b-btn(variant='outline-secondary'
-          @click='closeDialog()') Cancel
-</template>
-
-<script>
-'use strict'
-
-import actions from '@/store/action-types'
-
-export default {
-  name: 'edit-request',
-  props: {
-    toast: { required: true },
-    events: { required: true }
-  },
-  data () {
-    return {
-      editVisible: false,
-      form: {
-        requestId: '',
-        requestText: '',
-        status: 'Updated'
-      }
-    }
-  },
-  created () {
-    this.events.$on('edit', this.openDialog)
-  },
-  methods: {
-    closeDialog () {
-      this.form.requestId = ''
-      this.form.requestText = ''
-      this.form.status = 'Updated'
-      this.editVisible = false
-    },
-    focusRequestText (e) {
-      this.$refs.toFocus.focus()
-    },
-    openDialog (request) {
-      this.form.requestId = request.requestId
-      this.form.requestText = request.text
-      this.editVisible = true
-      this.focusRequestText(null)
-    },
-    trimText () {
-      this.form.requestText = this.form.requestText.trim()
-    },
-    async saveRequest () {
-      await this.$store.dispatch(actions.UPDATE_REQUEST, {
-        progress: this.$Progress,
-        requestId: this.form.requestId,
-        updateText: this.form.requestText,
-        status: this.form.status
-      })
-      if (this.form.status === 'Answered') {
-        this.toast.showToast('Request updated and removed from active journal', { theme: 'success' })
-      } else {
-        this.toast.showToast('Request updated', { theme: 'success' })
-      }
-      this.closeDialog()
-    }
-  }
-}
-</script>

src/app/src/components/request/FullRequest.vue

@@ -1,57 +0,0 @@
-<template lang="pug">
-span
-  b-modal(v-model='historyVisible'
-          header-bg-variant='mpj'
-          header-text-variant='light'
-          size='lg'
-          title='Prayer Request History'
-          @shows='focusRequestText')
-    b-list-group(v-if='null !== full'
-                 flush)
-      full-request-history(v-for='item in full.history'
-                           :key='item.asOf'
-                           :history='item')
-    div.w-100.text-right(slot='modal-footer')
-      b-btn(variant='primary'
-            @click='closeDialog()') Close
-</template>
-
-<script>
-'use strict'
-
-import FullRequestHistory from './FullRequestHistory'
-
-import api from '@/api'
-
-export default {
-  name: 'full-request',
-  components: {
-    FullRequestHistory
-  },
-  props: {
-    events: { required: true }
-  },
-  data () {
-    return {
-      historyVisible: false,
-      full: null
-    }
-  },
-  created () {
-    this.events.$on('full', this.openDialog)
-  },
-  methods: {
-    closeDialog () {
-      this.full = null
-      this.historyVisible = false
-    },
-    async openDialog (requestId) {
-      this.historyVisible = true
-      this.$Progress.start()
-      const req = await api.getFullRequest(requestId)
-      this.full = req.data
-      this.$Progress.finish()
-    }
-  }
-}
-</script>

src/app/src/components/request/FullRequestHistory.vue

@@ -1,28 +0,0 @@
-<template lang="pug">
-b-list-group-item
-  | {{ history.status }}
-  |
-  small.text-muted {{ asOf }}
-  div(v-if='hasText').mpj-request-text {{ history.text }}
-</template>
-
-<script>
-'use strict'
-
-import moment from 'moment'
-
-export default {
-  name: 'full-request-history',
-  props: {
-    history: { required: true }
-  },
-  computed: {
-    asOf () {
-      return moment(this.history.asOf).fromNow()
-    },
-    hasText () {
-      return this.history.text.length > 0
-    }
-  }
-}
-</script>

src/app/src/components/request/NewRequest.vue

@@ -1,71 +0,0 @@
-<template lang="pug">
-div
-  b-btn(@click='openDialog()' size='sm' variant='primary')
-    icon(name='plus')
-    | &nbsp; Add a New Request
-  b-modal(v-model='showNewVisible'
-          header-bg-variant='mpj'
-          header-text-variant='light'
-          size='lg'
-          title='Add a New Prayer Request'
-          @shown='focusRequestText')
-    b-form
-      b-form-group(label='Prayer Request'
-                   label-for='request_text')
-        b-textarea#request_text(ref='toFocus'
-                                v-model='form.requestText'
-                                :rows='10'
-                                @blur='trimText()')
-    div.w-100.text-right(slot='modal-footer')
-      b-btn(variant='primary'
-            @click='saveRequest()') Save
-      | &nbsp; &nbsp;
-      b-btn(variant='outline-secondary'
-            @click='closeDialog()') Cancel
-  toast(ref='toast')
-</template>
-
-<script>
-'use strict'
-
-import actions from '@/store/action-types'
-
-export default {
-  name: 'new-request',
-  data () {
-    return {
-      showNewVisible: false,
-      form: {
-        requestText: ''
-      },
-      formLabelWidth: '120px'
-    }
-  },
-  mounted () {
-    this.$refs.toast.setOptions({ position: 'bottom right' })
-  },
-  methods: {
-    closeDialog () {
-      this.form.requestText = ''
-      this.showNewVisible = false
-    },
-    focusRequestText (e) {
-      this.$refs.toFocus.focus()
-    },
-    openDialog () {
-      this.showNewVisible = true
-    },
-    trimText () {
-      this.form.requestText = this.form.requestText.trim()
-    },
-    async saveRequest () {
-      await this.$store.dispatch(actions.ADD_REQUEST, {
-        progress: this.$Progress,
-        requestText: this.form.requestText
-      })
-      this.$refs.toast.showToast('New prayer request added', { theme: 'success' })
-      this.closeDialog()
-    }
-  }
-}
-</script>

src/app/src/components/request/NotesEdit.vue

@@ -1,116 +0,0 @@
-<template lang="pug">
-b-modal(v-model='notesVisible'
-        header-bg-variant='mpj'
-        header-text-variant='light'
-        size='lg'
-        title='Add Notes to Prayer Request'
-        @edit='openDialog()'
-        @shows='focusNotes')
-  b-form
-    b-form-group(label='Notes'
-                 label-for='notes')
-      b-textarea#notes(ref='toFocus'
-                       v-model='form.notes'
-                       :rows='10'
-                       @blur='trimText()')
-  div(v-if='hasPriorNotes')
-    p.text-center: strong Prior Notes for This Request
-    b-list-group(flush)
-      b-list-group-item(v-for='note in priorNotes'
-                        :key='note.asOf')
-        small.text-muted: date-from-now(:value='note.asOf')
-        br
-        div.mpj-request-text {{ note.notes }}
-  div(v-else-if='noPriorNotes').text-center.text-muted There are no prior notes for this request
-  div(v-else).text-center
-    b-btn(variant='outline-secondary'
-          @click='loadNotes()') Load Prior Notes
-  div.w-100.text-right(slot='modal-footer')
-    b-btn(variant='primary'
-          @click='saveNotes()') Save
-    | &nbsp; &nbsp;
-    b-btn(variant='outline-secondary'
-          @click='closeDialog()') Cancel
-</template>
-
-<script>
-'use strict'
-
-import api from '@/api'
-
-export default {
-  name: 'notes-edit',
-  props: {
-    toast: { required: true },
-    events: { required: true }
-  },
-  data () {
-    return {
-      notesVisible: false,
-      form: {
-        requestId: '',
-        notes: ''
-      },
-      priorNotes: [],
-      priorNotesLoaded: false
-    }
-  },
-  computed: {
-    hasPriorNotes () {
-      return this.priorNotesLoaded && this.priorNotes.length > 0
-    },
-    noPriorNotes () {
-      return this.priorNotesLoaded && this.priorNotes.length === 0
-    }
-  },
-  created () {
-    this.events.$on('notes', this.openDialog)
-  },
-  methods: {
-    closeDialog () {
-      this.form.requestId = ''
-      this.form.notes = ''
-      this.priorNotes = []
-      this.priorNotesLoaded = false
-      this.notesVisible = false
-    },
-    focusNotes (e) {
-      this.$refs.toFocus.focus()
-    },
-    async loadNotes () {
-      this.$Progress.start()
-      try {
-        const notes = await api.getNotes(this.form.requestId)
-        this.priorNotes = notes.data
-        console.log(this.priorNotes)
-        this.$Progress.finish()
-      } catch (e) {
-        console.error(e)
-        this.$Progress.fail()
-      } finally {
-        this.priorNotesLoaded = true
-      }
-    },
-    openDialog (request) {
-      this.form.requestId = request.requestId
-      this.notesVisible = true
-      this.focusNotes(null)
-    },
-    async saveNotes () {
-      this.$Progress.start()
-      try {
-        await api.addNote(this.form.requestId, this.form.notes)
-        this.$Progress.finish()
-        this.toast.showToast('Added notes', { theme: 'success' })
-        this.closeDialog()
-      } catch (e) {
-        console.error(e)
-        this.$Progress.fail()
-      }
-    },
-    trimText () {
-      this.form.notes = this.form.notes.trim()
-    }
-  }
-}
-</script>

src/app/src/components/request/RequestCard.vue

@@ -1,59 +0,0 @@
-<template lang="pug">
-b-col(md='6' lg='4')
-  .mpj-request-card
-    b-card-header.text-center.py-1.
-      #[b-btn(@click='markPrayed()' variant='outline-primary' title='Pray' size='sm'): icon(name='check')]
-      #[b-btn(@click.stop='showEdit()' variant='outline-secondary' title='Edit' size='sm'): icon(name='pencil')]
-      #[b-btn(@click.stop='showNotes()' variant='outline-secondary' title='Add Notes' size='sm'): icon(name='file-text-o')]
-      #[b-btn(@click.stop='showFull()' variant='outline-secondary' title='View Full Request' size='sm'): icon(name='search')]
-    b-card-body.p-0
-      p.card-text.mpj-request-text.mb-1.px-3.pt-3
-        | {{ request.text }}
-      p.card-text.p-0.pr-1.text-right: small.text-muted: em
-        = '(last activity '
-        date-from-now(:value='request.asOf')
-        | )
-</template>
-
-<script>
-'use strict'
-
-import actions from '@/store/action-types'
-
-export default {
-  name: 'request-card',
-  props: {
-    request: { required: true },
-    toast: { required: true },
-    events: { required: true }
-  },
-  methods: {
-    async markPrayed () {
-      await this.$store.dispatch(actions.UPDATE_REQUEST, {
-        progress: this.$Progress,
-        requestId: this.request.requestId,
-        status: 'Prayed',
-        updateText: ''
-      })
-      this.toast.showToast('Request marked as prayed', { theme: 'success' })
-    },
-    showEdit () {
-      this.events.$emit('edit', this.request)
-    },
-    showFull () {
-      this.events.$emit('full', this.request.requestId)
-    },
-    showNotes () {
-      this.events.$emit('notes', this.request)
-    }
-  }
-}
-</script>
-
-<style>
-.mpj-request-card {
-  border: solid 1px darkgray;
-  border-radius: 5px;
-  margin-bottom: 15px;
-}
-</style>

src/app/src/components/user/LogOn.vue

@@ -1,20 +0,0 @@
-<template lang="pug">
-article
-  pageTitle(title='Logging On')
-  p Logging you on...
-</template>
-
-<script>
-'use strict'
-
-import AuthService from '@/auth/AuthService'
-
-export default {
-  name: 'log-on',
-  created () {
-    this.$Progress.start()
-    new AuthService().handleAuthentication(this.$store, this.$router)
-    // Auth service redirects to dashboard, which restarts the progress bar
-  }
-}
-</script>

src/app/src/main.js

@@ -1,52 +0,0 @@
-// The Vue build version to load with the `import` command
-// (runtime-only or standalone) has been set in webpack.base.conf with an alias.
-import Vue from 'vue'
-import BootstrapVue from 'bootstrap-vue'
-import Icon from 'vue-awesome/components/Icon'
-import VueProgressBar from 'vue-progressbar'
-import VueToast from 'vue-toast'
-
-import 'bootstrap-vue/dist/bootstrap-vue.css'
-import 'bootstrap/dist/css/bootstrap.css'
-import 'vue-toast/dist/vue-toast.min.css'
-
-// Only import the icons we need; the whole set is ~500K!
-import 'vue-awesome/icons/check'
-import 'vue-awesome/icons/file-text-o'
-import 'vue-awesome/icons/pencil'
-import 'vue-awesome/icons/plus'
-import 'vue-awesome/icons/search'
-
-import App from './App'
-import router from './router'
-import store from './store'
-import DateFromNow from './components/common/DateFromNow'
-import PageTitle from './components/common/PageTitle'
-
-Vue.config.productionTip = false
-
-Vue.use(BootstrapVue)
-Vue.use(VueProgressBar, {
-  color: 'yellow',
-  failedColor: 'red',
-  height: '5px',
-  transition: {
-    speed: '0.2s',
-    opacity: '0.6s',
-    termination: 1000
-  }
-})
-
-Vue.component('icon', Icon)
-Vue.component('date-from-now', DateFromNow)
-Vue.component('page-title', PageTitle)
-Vue.component('toast', VueToast)
-
-/* eslint-disable no-new */
-new Vue({
-  el: '#app',
-  router,
-  store,
-  template: '<App/>',
-  components: { App }
-})

src/app/src/router/index.js

@@ -1,42 +0,0 @@
-import Vue from 'vue'
-import Router from 'vue-router'
-
-import Answered from '@/components/Answered'
-import AnsweredDetail from '@/components/AnsweredDetail'
-import Home from '@/components/Home'
-import Journal from '@/components/Journal'
-import LogOn from '@/components/user/LogOn'
-
-Vue.use(Router)
-
-export default new Router({
-  mode: 'history',
-  routes: [
-    {
-      path: '/',
-      name: 'Home',
-      component: Home
-    },
-    {
-      path: '/answered/:id',
-      name: 'AnsweredDetail',
-      component: AnsweredDetail,
-      props: true
-    },
-    {
-      path: '/answered',
-      name: 'Answered',
-      component: Answered
-    },
-    {
-      path: '/journal',
-      name: 'Journal',
-      component: Journal
-    },
-    {
-      path: '/user/log-on',
-      name: 'LogOn',
-      component: LogOn
-    }
-  ]
-})

src/app/src/store/action-types.js

@@ -1,10 +0,0 @@
-'use strict'
-
-export default {
-  /** Action to add a prayer request (pass request text) */
-  ADD_REQUEST: 'add-request',
-  /** Action to load the user's prayer journal */
-  LOAD_JOURNAL: 'load-journal',
-  /** Action to update a request */
-  UPDATE_REQUEST: 'update-request'
-}

src/app/src/store/index.js

@@ -1,116 +0,0 @@
-import Vue from 'vue'
-import Vuex from 'vuex'
-
-import api from '@/api'
-import AuthService from '@/auth/AuthService'
-
-import mutations from './mutation-types'
-import actions from './action-types'
-
-Vue.use(Vuex)
-
-this.auth0 = new AuthService()
-
-const logError = function (error) {
-  if (error.response) {
-    // The request was made and the server responded with a status code
-    // that falls out of the range of 2xx
-    console.log(error.response.data)
-    console.log(error.response.status)
-    console.log(error.response.headers)
-  } else if (error.request) {
-    // The request was made but no response was received
-    // `error.request` is an instance of XMLHttpRequest in the browser and an instance of
-    // http.ClientRequest in node.js
-    console.log(error.request)
-  } else {
-    // Something happened in setting up the request that triggered an Error
-    console.log('Error', error.message)
-  }
-  console.log(error.config)
-}
-
-export default new Vuex.Store({
-  state: {
-    user: JSON.parse(localStorage.getItem('user_profile') || '{}'),
-    isAuthenticated: (() => {
-      this.auth0.scheduleRenewal()
-      if (this.auth0.isAuthenticated()) {
-        api.setBearer(localStorage.getItem('id_token'))
-      }
-      return this.auth0.isAuthenticated()
-    })(),
-    journal: {},
-    isLoadingJournal: false
-  },
-  mutations: {
-    [mutations.LOADING_JOURNAL] (state, flag) {
-      state.isLoadingJournal = flag
-    },
-    [mutations.LOADED_JOURNAL] (state, journal) {
-      state.journal = journal
-    },
-    [mutations.REQUEST_ADDED] (state, newRequest) {
-      state.journal.push(newRequest)
-    },
-    [mutations.REQUEST_UPDATED] (state, request) {
-      let jrnl = state.journal.filter(it => it.requestId !== request.requestId)
-      if (request.lastStatus !== 'Answered') jrnl.push(request)
-      state.journal = jrnl
-    },
-    [mutations.USER_LOGGED_OFF] (state) {
-      state.user = {}
-      api.removeBearer()
-      state.isAuthenticated = false
-    },
-    [mutations.USER_LOGGED_ON] (state, user) {
-      localStorage.setItem('user_profile', JSON.stringify(user))
-      state.user = user
-      api.setBearer(localStorage.getItem('id_token'))
-      state.isAuthenticated = true
-    }
-  },
-  actions: {
-    async [actions.ADD_REQUEST] ({ commit }, { progress, requestText }) {
-      progress.start()
-      try {
-        const newRequest = await api.addRequest(requestText)
-        commit(mutations.REQUEST_ADDED, newRequest.data)
-        progress.finish()
-      } catch (err) {
-        logError(err)
-        progress.fail()
-      }
-    },
-    async [actions.LOAD_JOURNAL] ({ commit }, progress) {
-      commit(mutations.LOADED_JOURNAL, {})
-      progress.start()
-      commit(mutations.LOADING_JOURNAL, true)
-      api.setBearer(localStorage.getItem('id_token'))
-      try {
-        const jrnl = await api.journal()
-        commit(mutations.LOADED_JOURNAL, jrnl.data)
-        progress.finish()
-      } catch (err) {
-        logError(err)
-        progress.fail()
-      } finally {
-        commit(mutations.LOADING_JOURNAL, false)
-      }
-    },
-    async [actions.UPDATE_REQUEST] ({ commit }, { progress, requestId, status, updateText }) {
-      progress.start()
-      try {
-        await api.updateRequest({ requestId, status, updateText })
-        const request = await api.getRequest(requestId)
-        commit(mutations.REQUEST_UPDATED, request.data)
-        progress.finish()
-      } catch (err) {
-        logError(err)
-        progress.fail()
-      }
-    }
-  },
-  getters: {},
-  modules: {}
-})

src/app/src/store/mutation-types.js

@@ -1,16 +0,0 @@
-'use strict'
-
-export default {
-  /** Mutation for when the user's prayer journal is being loaded */
-  LOADING_JOURNAL: 'loading-journal',
-  /** Mutation for when the user's prayer journal has been loaded */
-  LOADED_JOURNAL: 'journal-loaded',
-  /** Mutation for adding a new prayer request (pass text) */
-  REQUEST_ADDED: 'request-added',
-  /** Mutation to replace a prayer request at the top of the current journal */
-  REQUEST_UPDATED: 'request-updated',
-  /** Mutation for logging a user off */
-  USER_LOGGED_OFF: 'user-logged-off',
-  /** Mutation for logging a user on (pass user) */
-  USER_LOGGED_ON: 'user-logged-on'
-}

src/app/static/silent.html

@@ -1,22 +0,0 @@
-<!DOCTYPE html>
-<html>
-<head>
-  <meta charset="utf-8">
-  <script src="https://cdn.auth0.com/js/auth0/8.9/auth0.min.js"></script>
-  <script>
-    var webAuth = new auth0.WebAuth({
-      domain: 'djs-consulting.auth0.com',
-      clientID: 'Of2s0RQCQ3mt3dwIkOBY5h85J9sXbF2n',
-      scope: 'openid profile email',
-      responseType: 'token id_token',
-      redirectUri: location.protocol + '//' + location.host + '/static/silent.html'
-    })
-  </script>
-  <script>
-    webAuth.parseHash(window.location.hash, function (err, response) {
-      parent.postMessage(err || response, location.protocol + '//' + location.host);
-    })
-  </script>
-</head>
-<body></body>
-</html>

src/app/test/e2e/custom-assertions/elementCount.js

@@ -1,26 +0,0 @@
-// A custom Nightwatch assertion.
-// the name of the method is the filename.
-// can be used in tests like this:
-//
-//   browser.assert.elementCount(selector, count)
-//
-// for how to write custom assertions see
-// http://nightwatchjs.org/guide#writing-custom-assertions
-exports.assertion = function (selector, count) {
-  this.message = 'Testing if element <' + selector + '> has count: ' + count
-  this.expected = count
-  this.pass = function (val) {
-    return val === this.expected
-  }
-  this.value = function (res) {
-    return res.value
-  }
-  this.command = function (cb) {
-    var self = this
-    return this.api.execute(function (selector) {
-      return document.querySelectorAll(selector).length
-    }, [selector], function (res) {
-      cb.call(self, res)
-    })
-  }
-}

src/app/test/e2e/nightwatch.conf.js

@@ -1,46 +0,0 @@
-require('babel-register')
-var config = require('../../config')
-
-// http://nightwatchjs.org/gettingstarted#settings-file
-module.exports = {
-  src_folders: ['test/e2e/specs'],
-  output_folder: 'test/e2e/reports',
-  custom_assertions_path: ['test/e2e/custom-assertions'],
-
-  selenium: {
-    start_process: true,
-    server_path: require('selenium-server').path,
-    host: '127.0.0.1',
-    port: 4444,
-    cli_args: {
-      'webdriver.chrome.driver': require('chromedriver').path
-    }
-  },
-
-  test_settings: {
-    default: {
-      selenium_port: 4444,
-      selenium_host: 'localhost',
-      silent: true,
-      globals: {
-        devServerURL: 'http://localhost:' + (process.env.PORT || config.dev.port)
-      }
-    },
-
-    chrome: {
-      desiredCapabilities: {
-        browserName: 'chrome',
-        javascriptEnabled: true,
-        acceptSslCerts: true
-      }
-    },
-
-    firefox: {
-      desiredCapabilities: {
-        browserName: 'firefox',
-        javascriptEnabled: true,
-        acceptSslCerts: true
-      }
-    }
-  }
-}

src/app/test/e2e/runner.js

@@ -1,33 +0,0 @@
-// 1. start the dev server using production config
-process.env.NODE_ENV = 'testing'
-var server = require('../../build/dev-server.js')
-
-server.ready.then(() => {
-  // 2. run the nightwatch test suite against it
-  // to run in additional browsers:
-  //    1. add an entry in test/e2e/nightwatch.conf.json under "test_settings"
-  //    2. add it to the --env flag below
-  // or override the environment flag, for example: `npm run e2e -- --env chrome,firefox`
-  // For more information on Nightwatch's config file, see
-  // http://nightwatchjs.org/guide#settings-file
-  var opts = process.argv.slice(2)
-  if (opts.indexOf('--config') === -1) {
-    opts = opts.concat(['--config', 'test/e2e/nightwatch.conf.js'])
-  }
-  if (opts.indexOf('--env') === -1) {
-    opts = opts.concat(['--env', 'chrome'])
-  }
-
-  var spawn = require('cross-spawn')
-  var runner = spawn('./node_modules/.bin/nightwatch', opts, { stdio: 'inherit' })
-
-  runner.on('exit', function (code) {
-    server.close()
-    process.exit(code)
-  })
-
-  runner.on('error', function (err) {
-    server.close()
-    throw err
-  })
-})

src/app/test/e2e/specs/test.js

@@ -1,19 +0,0 @@
-// For authoring Nightwatch tests, see
-// http://nightwatchjs.org/guide#usage
-
-module.exports = {
-  'default e2e tests': function (browser) {
-    // automatically uses dev Server port from /config.index.js
-    // default: http://localhost:8080
-    // see nightwatch.conf.js
-    const devServer = browser.globals.devServerURL
-
-    browser
-      .url(devServer)
-      .waitForElementVisible('#app', 5000)
-      .assert.elementPresent('.hello')
-      .assert.containsText('h1', 'Welcome to Your Vue.js App')
-      .assert.elementCount('img', 1)
-      .end()
-  }
-}

src/app/test/unit/.eslintrc

@@ -1,9 +0,0 @@
-{
-  "env": {
-    "mocha": true
-  },
-  "globals": {
-    "expect": true,
-    "sinon": true
-  }
-}

src/app/test/unit/index.js

@@ -1,13 +0,0 @@
-import Vue from 'vue'
-
-Vue.config.productionTip = false
-
-// require all test files (files that ends with .spec.js)
-const testsContext = require.context('./specs', true, /\.spec$/)
-testsContext.keys().forEach(testsContext)
-
-// require all src files except main.js for coverage.
-// you can also change this to match only the subset of files that
-// you want coverage for.
-const srcContext = require.context('../../src', true, /^\.\/(?!main(\.js)?$)/)
-srcContext.keys().forEach(srcContext)

src/app/test/unit/karma.conf.js

@@ -1,33 +0,0 @@
-// This is a karma config file. For more details see
-//   http://karma-runner.github.io/0.13/config/configuration-file.html
-// we are also using it with karma-webpack
-//   https://github.com/webpack/karma-webpack
-
-var webpackConfig = require('../../build/webpack.test.conf')
-
-module.exports = function (config) {
-  config.set({
-    // to run in additional browsers:
-    // 1. install corresponding karma launcher
-    //    http://karma-runner.github.io/0.13/config/browsers.html
-    // 2. add it to the `browsers` array below.
-    browsers: ['PhantomJS'],
-    frameworks: ['mocha', 'sinon-chai', 'phantomjs-shim'],
-    reporters: ['spec', 'coverage'],
-    files: ['./index.js'],
-    preprocessors: {
-      './index.js': ['webpack', 'sourcemap']
-    },
-    webpack: webpackConfig,
-    webpackMiddleware: {
-      noInfo: true
-    },
-    coverageReporter: {
-      dir: './coverage',
-      reporters: [
-        { type: 'lcov', subdir: '.' },
-        { type: 'text-summary' }
-      ]
-    }
-  })
-}