Fix tryJournalById function (#42)

Also update .NET deps

.gitignore

@@ -252,10 +252,15 @@ paket-files/
 .idea/
 *.sln.iml
 
+# Ionide VSCode extension
+.ionide
+
 # Compiled files / application
-src/api/build
+src/build
-src/api/MyPrayerJournal.Api/wwwroot/index.html
+src/MyPrayerJournal.Api/wwwroot/favicon.ico
-src/api/MyPrayerJournal.Api/wwwroot/static
+src/MyPrayerJournal.Api/wwwroot/index.html
-src/api/MyPrayerJournal.Api/appsettings.development.json
+src/MyPrayerJournal.Api/wwwroot/css
+src/MyPrayerJournal.Api/wwwroot/js
+src/MyPrayerJournal.Api/appsettings.development.json
 /build
 src/*.exe

docs/CNAME

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

docs/index.md

@@ -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,22 +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.
-
-## 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.
 
 ## Snoozing Requests
 
-There may be a time where a request does not need to appear. The fifth 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.
+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.
 
-## Answered Requests
+## Viewing a Request and Its History
 
-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.
+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.
+
+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.
 
 ## Final Notes
 
-- myPrayerJournal is currently in public beta. 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 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.

src/MyPrayerJournal.Api/Data.fs

@@ -0,0 +1,186 @@
+namespace MyPrayerJournal
+
+open System
+open System.Collections.Generic
+
+/// JSON converters for various DUs
+module Converters =
+  
+  open Microsoft.FSharpLu.Json
+  open Newtonsoft.Json
+
+  /// JSON converter for request IDs
+  type RequestIdJsonConverter () =
+    inherit JsonConverter<RequestId> ()
+    override __.WriteJson(writer : JsonWriter, value : RequestId, _ : JsonSerializer) =
+      (RequestId.toString >> writer.WriteValue) value
+    override __.ReadJson(reader: JsonReader, _ : Type, _ : RequestId, _ : bool, _ : JsonSerializer) =
+      (string >> RequestId.fromIdString) reader.Value
+
+  /// JSON converter for user IDs
+  type UserIdJsonConverter () =
+    inherit JsonConverter<UserId> ()
+    override __.WriteJson(writer : JsonWriter, value : UserId, _ : JsonSerializer) =
+      (UserId.toString >> writer.WriteValue) value
+    override __.ReadJson(reader: JsonReader, _ : Type, _ : UserId, _ : bool, _ : JsonSerializer) =
+      (string >> UserId) reader.Value
+
+  /// JSON converter for Ticks
+  type TicksJsonConverter () =
+    inherit JsonConverter<Ticks> ()
+    override __.WriteJson(writer : JsonWriter, value : Ticks, _ : JsonSerializer) =
+      (Ticks.toLong >> writer.WriteValue) value
+    override __.ReadJson(reader: JsonReader, _ : Type, _ : Ticks, _ : bool, _ : JsonSerializer) =
+      (string >> int64 >> Ticks) reader.Value
+
+  /// A sequence of all custom converters needed for myPrayerJournal
+  let all : JsonConverter seq =
+    seq {
+      yield RequestIdJsonConverter ()
+      yield UserIdJsonConverter ()
+      yield TicksJsonConverter ()
+      yield CompactUnionJsonConverter true
+      }
+
+
+/// RavenDB index declarations
+module Indexes =
+  
+  open Raven.Client.Documents.Indexes
+
+  /// Index requests for a journal view
+  type Requests_AsJournal () as this =
+    inherit AbstractJavaScriptIndexCreationTask ()
+    do
+      this.Maps <- HashSet<string> [
+        """docs.Requests.Select(req => new {
+            requestId = req.Id.Replace("Requests/", ""),
+            userId = req.userId,
+            text = req.history.Where(hist => hist.text != null).OrderByDescending(hist => hist.asOf).First().text,
+            asOf = req.history.OrderByDescending(hist => hist.asOf).First().asOf,
+            lastStatus = req.history.OrderByDescending(hist => hist.asOf).First().status,
+            snoozedUntil = req.snoozedUntil,
+            showAfter = req.showAfter,
+            recurType = req.recurType,
+            recurCount = req.recurCount
+        })"""
+        ]
+      this.Fields <-
+        [ "requestId",  IndexFieldOptions (Storage = Nullable FieldStorage.Yes)
+          "text",       IndexFieldOptions (Storage = Nullable FieldStorage.Yes)
+          "asOf",       IndexFieldOptions (Storage = Nullable FieldStorage.Yes)
+          "lastStatus", IndexFieldOptions (Storage = Nullable FieldStorage.Yes)
+          ]
+        |> dict
+        |> Dictionary<string, IndexFieldOptions>
+
+
+/// All data manipulations within myPrayerJournal
+module Data =
+  
+  open FSharp.Control.Tasks.V2.ContextInsensitive
+  open Indexes
+  open Microsoft.FSharpLu
+  open Raven.Client.Documents
+  open Raven.Client.Documents.Linq
+  open Raven.Client.Documents.Session
+
+  /// Add a history entry
+  let addHistory reqId (hist : History) (sess : IAsyncDocumentSession) =
+    sess.Advanced.Patch<Request, History> (
+      RequestId.toString reqId,
+      (fun r -> r.history :> IEnumerable<History>),
+      fun (h : JavaScriptArray<History>) -> h.Add (hist) :> obj)
+  
+  /// Add a note
+  let addNote reqId (note : Note) (sess : IAsyncDocumentSession) =
+    sess.Advanced.Patch<Request, Note> (
+      RequestId.toString reqId,
+      (fun r -> r.notes :> IEnumerable<Note>),
+      fun (h : JavaScriptArray<Note>) -> h.Add (note) :> obj)
+
+  /// Add a request
+  let addRequest req (sess : IAsyncDocumentSession) =
+    sess.StoreAsync (req, req.Id)
+
+  /// Retrieve all answered requests for the given user
+  let answeredRequests userId (sess : IAsyncDocumentSession) =
+    task {
+      let! reqs =
+        sess.Query<JournalRequest, Requests_AsJournal>()
+          .Where(fun r -> r.userId = userId && r.lastStatus = "Answered")
+          .OrderByDescending(fun r -> r.asOf)
+          .ProjectInto<JournalRequest>()
+          .ToListAsync ()
+      return List.ofSeq reqs
+      }
+    
+  /// Retrieve the user's current journal
+  let journalByUserId userId (sess : IAsyncDocumentSession) =
+    task {
+      let! jrnl =
+        sess.Query<JournalRequest, Requests_AsJournal>()
+          .Where(fun r -> r.userId = userId && r.lastStatus <> "Answered")
+          .OrderBy(fun r -> r.asOf)
+          .ProjectInto<JournalRequest>()
+          .ToListAsync()
+      return
+        jrnl
+        |> Seq.map (fun r -> r.history <- []; r.notes <- []; r)
+        |> List.ofSeq
+      }
+
+  /// Save changes in the current document session
+  let saveChanges (sess : IAsyncDocumentSession) =
+    sess.SaveChangesAsync ()
+
+  /// Retrieve a request, including its history and notes, by its ID and user ID
+  let tryFullRequestById reqId userId (sess : IAsyncDocumentSession) =
+    task {
+      let! req = RequestId.toString reqId |> sess.LoadAsync
+      return match Option.fromObject req with Some r when r.userId = userId -> Some r | _ -> None
+      }
+
+
+  /// Retrieve a request by its ID and user ID (without notes and history)
+  let tryRequestById reqId userId (sess : IAsyncDocumentSession) =
+    task {
+      match! tryFullRequestById reqId userId sess with
+      | Some r -> return Some { r with history = []; notes = [] }
+      | _ -> return None
+      }
+  
+  /// Retrieve notes for a request by its ID and user ID
+  let notesById reqId userId (sess : IAsyncDocumentSession) =
+    task {
+      match! tryFullRequestById reqId userId sess with
+      | Some req -> return req.notes
+      | None -> return []
+      }
+      
+  /// Retrieve a journal request by its ID and user ID
+  let tryJournalById reqId userId (sess : IAsyncDocumentSession) =
+    task {
+      let! req =
+        sess.Query<Request, Requests_AsJournal>()
+          .Where(fun x -> x.Id = (RequestId.toString reqId) && x.userId = userId)
+          .ProjectInto<JournalRequest>()
+          .FirstOrDefaultAsync ()
+      return
+        Option.fromObject req
+        |> Option.map (fun r -> r.history <- []; r.notes <- []; r)
+      }
+      
+  /// Update the recurrence for a request
+  let updateRecurrence reqId recurType recurCount (sess : IAsyncDocumentSession) =
+    sess.Advanced.Patch<Request, Recurrence> (RequestId.toString reqId, (fun r -> r.recurType),  recurType)
+    sess.Advanced.Patch<Request, int16>      (RequestId.toString reqId, (fun r -> r.recurCount), recurCount)
+
+  /// Update a snoozed request
+  let updateSnoozed reqId until (sess : IAsyncDocumentSession) =
+    sess.Advanced.Patch<Request, Ticks> (RequestId.toString reqId, (fun r -> r.snoozedUntil),  until)
+    sess.Advanced.Patch<Request, Ticks> (RequestId.toString reqId, (fun r -> r.showAfter),     until)
+
+  /// Update the "show after" timestamp for a request
+  let updateShowAfter reqId showAfter (sess : IAsyncDocumentSession) =
+    sess.Advanced.Patch<Request, Ticks> (RequestId.toString reqId, (fun r -> r.showAfter), showAfter)

src/MyPrayerJournal.Api/Domain.fs

@@ -0,0 +1,169 @@
+[<AutoOpen>]
+/// The data model for myPrayerJournal
+module MyPrayerJournal.Domain
+
+open Cuid
+
+/// Request ID is a CUID
+type RequestId =
+  | RequestId of Cuid
+module RequestId =
+  /// The string representation of the request ID
+  let toString x = match x with RequestId y -> (Cuid.toString >> sprintf "Requests/%s") y
+  /// Create a request ID from a string representation
+  let fromIdString (y : string) = (Cuid >> RequestId) <| y.Replace("Requests/", "")
+
+
+/// User ID is a string (the "sub" part of the JWT)
+type UserId =
+  | UserId of string
+module UserId =
+  /// The string representation of the user ID
+  let toString x = match x with UserId y -> y
+
+
+/// A long integer representing seconds since the epoch
+type Ticks =
+  | Ticks of int64
+module Ticks =
+  /// The int64 (long) representation of ticks
+  let toLong x = match x with Ticks y -> y
+
+
+/// How frequently a request should reappear after it is marked "Prayed"
+type Recurrence =
+  | Immediate
+  | Hours
+  | Days
+  | Weeks
+module Recurrence =
+  /// Create a recurrence value from a string
+  let fromString x =
+    match x with
+    | "Immediate" -> Immediate
+    | "Hours" -> Hours
+    | "Days" -> Days
+    | "Weeks" -> Weeks
+    | _ -> invalidOp (sprintf "%s is not a valid recurrence" x)
+  /// The duration of the recurrence
+  let duration x =
+    match x with
+    | Immediate ->     0L
+    | Hours ->   3600000L
+    | Days ->   86400000L
+    | Weeks -> 604800000L
+
+
+/// The action taken on a request as part of a history entry
+type RequestAction =
+  | Created
+  | Prayed
+  | Updated
+  | Answered
+module RequestAction =
+  /// Create a RequestAction from a string
+  let fromString x =
+    match x with
+    | "Created" -> Created
+    | "Prayed" -> Prayed
+    | "Updated" -> Updated
+    | "Answered" -> Answered
+    | _ -> (sprintf "Bad request action %s" >> invalidOp) x
+
+
+/// 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   : Ticks
+    /// The status for this history entry
+    status : RequestAction
+    /// The text of the update, if applicable
+    text   : string option
+    }
+with
+  /// An empty history entry
+  static member empty =
+    { asOf   = Ticks 0L
+      status = Created
+      text   = None
+      }
+
+/// 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  : Ticks
+    /// The text of the notes
+    notes : string
+    }
+with
+  /// An empty note
+  static member empty =
+    { asOf  = Ticks 0L
+      notes = ""
+      }
+
+/// Request is the identifying record for a prayer request
+[<CLIMutable; NoComparison; NoEquality>]
+type Request =
+  { /// The ID of the request
+    Id           : string
+    /// The time this request was initially entered
+    enteredOn    : Ticks
+    /// 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 : Ticks
+    /// The time at which this request should reappear in the user's journal by recurrence
+    showAfter    : Ticks
+    /// 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           = ""
+      enteredOn    = Ticks 0L
+      userId       = UserId ""
+      snoozedUntil = Ticks 0L
+      showAfter    = Ticks 0L
+      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.
+// RavenDB doesn't like the "@"-suffixed properties from record types in a ProjectInto clause
+[<NoComparison; NoEquality>]
+type JournalRequest () =
+  /// The ID of the request (just the CUID part)
+  [<DefaultValue>] val mutable requestId : string
+  /// The ID of the user to whom the request belongs
+  [<DefaultValue>] val mutable userId : UserId
+  /// The current text of the request
+  [<DefaultValue>] val mutable text : string
+  /// The last time action was taken on the request
+  [<DefaultValue>] val mutable asOf : Ticks
+  /// The last status for the request
+  [<DefaultValue>] val mutable lastStatus : string
+  /// The time that this request should reappear in the user's journal
+  [<DefaultValue>] val mutable snoozedUntil : Ticks
+  /// The time after which this request should reappear in the user's journal by configured recurrence
+  [<DefaultValue>] val mutable showAfter : Ticks
+  /// The type of recurrence for this request
+  [<DefaultValue>] val mutable recurType : Recurrence
+  /// How many of the recurrence intervals should occur between appearances in the journal
+  [<DefaultValue>] val mutable recurCount : int16
+  /// History entries for the request
+  [<DefaultValue>] val mutable history : History list
+  /// Note entries for the request
+  [<DefaultValue>] val mutable notes : Note list

src/MyPrayerJournal.Api/Handlers.fs

@@ -0,0 +1,378 @@
+/// HTTP handlers for the myPrayerJournal API
+[<RequireQualifiedAccess>]
+module MyPrayerJournal.Handlers
+
+open Giraffe
+
+/// Handler to return Vue files
+module Vue =
+  
+  /// The application index page
+  let app : HttpHandler = htmlFile "wwwroot/index.html"
+
+open System
+
+/// Handlers for error conditions
+module Error =
+
+  open Microsoft.Extensions.Logging
+
+  /// Handle errors
+  let error (ex : Exception) (log : ILogger) =
+    log.LogError (EventId(), ex, "An unhandled exception has occurred while executing the request.")
+    clearResponse >=> setStatusCode 500 >=> json ex.Message
+
+  /// Handle 404s from the API, sending known URL paths to the Vue app so that they can be handled there
+  let notFound : HttpHandler =
+    fun next ctx ->
+      [ "/journal"; "/legal"; "/request"; "/user" ]
+      |> List.filter ctx.Request.Path.Value.StartsWith
+      |> List.length
+      |> function
+      | 0 -> (setStatusCode 404 >=> json ([ "error", "not found" ] |> dict)) next ctx
+      | _ -> Vue.app next ctx
+
+open Cuid
+
+/// Handler helpers
+[<AutoOpen>]
+module private Helpers =
+  
+  open Microsoft.AspNetCore.Http
+  open Raven.Client.Documents
+  open System.Threading.Tasks
+  open System.Security.Claims
+
+  /// Create a RavenDB session
+  let session (ctx : HttpContext) =
+    let sess = ctx.GetService<IDocumentStore>().OpenAsyncSession ()
+    sess.Advanced.WaitForIndexesAfterSaveChanges ()
+    sess
+
+  /// Get the user's "sub" claim
+  let user (ctx : HttpContext) =
+    ctx.User.Claims |> Seq.tryFind (fun u -> u.Type = ClaimTypes.NameIdentifier)
+
+  /// Get the current user's ID
+  //  NOTE: this may raise if you don't run the request through the authorize handler first
+  let userId ctx =
+    ((user >> Option.get) ctx).Value |> UserId
+
+  /// Create a request ID from a string
+  let toReqId x =
+    let reqId =
+      match Cuid.ofString x with
+      | Ok cuid -> cuid
+      | Error msg -> invalidOp msg
+    RequestId reqId
+
+  /// Return a 201 CREATED response
+  let created next ctx =
+    setStatusCode 201 next ctx
+
+  /// The "now" time in JavaScript as Ticks
+  let jsNow () =
+    (int64 >> (*) 1000L >> Ticks) <| DateTime.UtcNow.Subtract(DateTime (1970, 1, 1, 0, 0, 0)).TotalSeconds
+  
+  /// Handler to return a 403 Not Authorized reponse
+  let notAuthorized : HttpHandler =
+    setStatusCode 403 >=> fun _ _ -> Task.FromResult<HttpContext option> None
+
+  /// Handler to require authorization
+  let authorize : HttpHandler =
+    fun next ctx -> match user ctx with Some _ -> next ctx | None -> notAuthorized next ctx
+  
+  /// Flip JSON result so we can pipe into it
+  let asJson<'T> next ctx (o : 'T) =
+    json o next ctx
+  
+  /// Work-around to let the Json.NET serializer synchronously deserialize from the request stream
+  // TODO: Remove this once there is an async serializer
+  let allowSyncIO : HttpHandler =
+    fun next ctx ->
+      match ctx.Features.Get<Features.IHttpBodyControlFeature>() with
+      | null -> ()
+      | f -> f.AllowSynchronousIO <- true
+      next ctx
+
+
+/// Strongly-typed models for post requests
+module Models =
+  
+  /// A history entry addition (AKA request update)
+  [<CLIMutable>]
+  type HistoryEntry =
+    { /// The status of the history update
+      status     : string
+      /// The text of the update
+      updateText : string
+      }
+  
+  /// An additional note
+  [<CLIMutable>]
+  type NoteEntry =
+    { /// The notes being added
+      notes : string
+      }
+  
+  /// Recurrence update
+  [<CLIMutable>]
+  type Recurrence =
+    { /// The recurrence type
+      recurType  : string
+      /// The recurrence cound
+      recurCount : int16
+      }
+
+  /// A prayer request
+  [<CLIMutable>]
+  type Request =
+    { /// The text of the request
+      requestText : string
+      /// The recurrence type
+      recurType   : string
+      /// The recurrence count
+      recurCount  : int16
+      }
+  
+  /// The time until which a request should not appear in the journal
+  [<CLIMutable>]
+  type SnoozeUntil =
+    { /// The time at which the request should reappear
+      until : int64
+      }
+
+open FSharp.Control.Tasks.V2.ContextInsensitive
+
+/// /api/journal URLs
+module Journal =
+  
+  /// GET /api/journal
+  let journal : HttpHandler =
+    authorize
+    >=> fun next ctx ->
+      task {
+        use  sess  = session ctx
+        let  usrId = userId  ctx
+        let! jrnl  = Data.journalByUserId usrId sess
+        return! json jrnl next ctx
+        }
+
+
+/// /api/request URLs
+module Request =
+  
+  /// POST /api/request
+  let add : HttpHandler =
+    authorize
+    >=> allowSyncIO
+    >=> fun next ctx ->
+      task {
+        let! r     = ctx.BindJsonAsync<Models.Request> ()
+        use  sess  = session ctx
+        let  reqId = (Cuid.generate >> RequestId) ()
+        let  usrId = userId ctx
+        let  now   = jsNow ()
+        do! Data.addRequest
+              { Request.empty with
+                  Id         = RequestId.toString reqId
+                  userId     = usrId
+                  enteredOn  = now
+                  showAfter  = Ticks 0L
+                  recurType  = Recurrence.fromString r.recurType
+                  recurCount = r.recurCount
+                  history    = [
+                    { asOf   = now
+                      status = Created
+                      text   = Some r.requestText
+                      }      
+                    ]
+                } sess
+        do! Data.saveChanges sess
+        match! Data.tryJournalById reqId usrId sess with
+        | Some req -> return! (setStatusCode 201 >=> json req) next ctx
+        | None -> return! Error.notFound next ctx
+        }
+
+  /// POST /api/request/[req-id]/history
+  let addHistory requestId : HttpHandler =
+    authorize
+    >=> allowSyncIO
+    >=> fun next ctx ->
+      task {
+        use sess  = session ctx
+        let usrId = userId ctx
+        let reqId = toReqId requestId
+        match! Data.tryRequestById reqId usrId sess with
+        | Some req ->
+            let! hist = ctx.BindJsonAsync<Models.HistoryEntry> ()
+            let  now  = jsNow ()
+            let  act  = RequestAction.fromString hist.status
+            Data.addHistory reqId
+              { asOf   = now
+                status = act
+                text   = match hist.updateText with null | "" -> None | x -> Some x
+                } sess
+            match act with
+            | Prayed ->
+                let nextShow =
+                  match Recurrence.duration req.recurType with
+                  | 0L -> 0L
+                  | duration -> (Ticks.toLong now) + (duration * int64 req.recurCount)
+                Data.updateShowAfter reqId (Ticks nextShow) sess
+            | _ -> ()
+            do! Data.saveChanges sess
+            return! created next ctx
+        | None -> return! Error.notFound next ctx
+        }
+  
+  /// POST /api/request/[req-id]/note
+  let addNote requestId : HttpHandler =
+    authorize
+    >=> allowSyncIO
+    >=> fun next ctx ->
+      task {
+        use sess  = session ctx
+        let usrId = userId ctx
+        let reqId = toReqId requestId
+        match! Data.tryRequestById reqId usrId sess with
+        | Some _ ->
+            let! notes = ctx.BindJsonAsync<Models.NoteEntry> ()
+            Data.addNote reqId { asOf = jsNow (); notes = notes.notes } sess
+            do! Data.saveChanges sess
+            return! created next ctx
+        | None -> return! Error.notFound next ctx
+        }
+          
+  /// GET /api/requests/answered
+  let answered : HttpHandler =
+    authorize
+    >=> fun next ctx ->
+      task {
+        use  sess  = session ctx
+        let  usrId = userId ctx
+        let! reqs  = Data.answeredRequests usrId sess
+        return! json reqs next ctx
+        }
+  
+  /// GET /api/request/[req-id]
+  let get requestId : HttpHandler =
+    authorize
+    >=> fun next ctx ->
+      task {
+        use sess  = session ctx
+        let usrId = userId ctx
+        match! Data.tryJournalById (toReqId requestId) usrId sess with
+        | Some req -> return! json req next ctx
+        | None -> return! Error.notFound next ctx
+        }
+  
+  /// GET /api/request/[req-id]/full
+  let getFull requestId : HttpHandler =
+    authorize
+    >=> fun next ctx ->
+      task {
+        use sess  = session ctx
+        let usrId = userId ctx
+        match! Data.tryFullRequestById (toReqId requestId) usrId sess with
+        | Some req -> return! json req next ctx
+        | None -> return! Error.notFound next ctx
+        }
+  
+  /// GET /api/request/[req-id]/notes
+  let getNotes requestId : HttpHandler =
+    authorize
+    >=> fun next ctx ->
+      task {
+        use  sess  = session ctx
+        let  usrId = userId ctx
+        let! notes = Data.notesById (toReqId requestId) usrId sess
+        return! json notes next ctx
+        }
+  
+  /// PATCH /api/request/[req-id]/show
+  let show requestId : HttpHandler =
+    authorize
+    >=> fun next ctx ->
+      task {
+        use sess  = session ctx
+        let usrId = userId ctx
+        let reqId = toReqId requestId
+        match! Data.tryRequestById reqId usrId sess with
+        | Some _ ->
+            Data.updateShowAfter reqId (Ticks 0L) sess
+            do! Data.saveChanges sess
+            return! setStatusCode 204 next ctx
+        | None -> return! Error.notFound next ctx
+        }
+  
+  /// PATCH /api/request/[req-id]/snooze
+  let snooze requestId : HttpHandler =
+    authorize
+    >=> allowSyncIO
+    >=> fun next ctx ->
+      task {
+        use sess  = session ctx
+        let usrId = userId ctx
+        let reqId = toReqId requestId
+        match! Data.tryRequestById reqId usrId sess with
+        | Some _ ->
+            let! until = ctx.BindJsonAsync<Models.SnoozeUntil> ()
+            Data.updateSnoozed reqId (Ticks until.until) sess
+            do! Data.saveChanges sess
+            return! setStatusCode 204 next ctx
+        | None -> return! Error.notFound next ctx
+        }
+
+  /// PATCH /api/request/[req-id]/recurrence
+  let updateRecurrence requestId : HttpHandler =
+    authorize
+    >=> allowSyncIO
+    >=> fun next ctx ->
+      task {
+        use sess  = session ctx
+        let usrId = userId ctx
+        let reqId = toReqId requestId
+        match! Data.tryRequestById reqId usrId sess with
+        | Some _ ->
+            let! recur = ctx.BindJsonAsync<Models.Recurrence> ()
+            let recurrence = Recurrence.fromString recur.recurType
+            Data.updateRecurrence reqId recurrence recur.recurCount sess
+            match recurrence with Immediate -> Data.updateShowAfter reqId (Ticks 0L) sess | _ -> ()
+            do! Data.saveChanges sess
+            return! setStatusCode 204 next ctx
+        | None -> return! Error.notFound next ctx
+        }
+
+open Giraffe.TokenRouter
+
+/// The routes for myPrayerJournal
+let webApp : HttpHandler =
+  router Error.notFound [
+    route "/" Vue.app
+    subRoute "/api/" [
+      GET [
+        route    "journal" Journal.journal
+        subRoute "request" [
+          route  "s/answered" Request.answered
+          routef "/%s/full"   Request.getFull
+          routef "/%s/notes"  Request.getNotes
+          routef "/%s"        Request.get
+          ]
+        ]
+      PATCH [
+        subRoute "request" [
+          routef "/%s/recurrence" Request.updateRecurrence
+          routef "/%s/show"       Request.show
+          routef "/%s/snooze"     Request.snooze
+          ]
+        ]
+      POST [
+        subRoute "request" [
+          route  ""            Request.add
+          routef "/%s/history" Request.addHistory
+          routef "/%s/note"    Request.addNote
+          ]
+        ]
+      ]
+    ]

src/MyPrayerJournal.Api/MyPrayerJournal.Api.fsproj

@@ -0,0 +1,34 @@
+<Project Sdk="Microsoft.NET.Sdk.Web">
+
+  <PropertyGroup>
+    <TargetFramework>netcoreapp3.1</TargetFramework>
+    <Version>2.1.4.0</Version>
+  </PropertyGroup>
+
+  <ItemGroup>
+    <Compile Include="Domain.fs" />
+    <Compile Include="Data.fs" />
+    <Compile Include="Handlers.fs" />
+    <Compile Include="Program.fs" />
+  </ItemGroup>
+
+  <ItemGroup>
+    <PackageReference Include="FunctionalCuid" Version="1.0.0" />
+    <PackageReference Include="Giraffe" Version="4.1.0" />
+    <PackageReference Include="Giraffe.TokenRouter" Version="1.0.0" />
+    <PackageReference Include="Microsoft.AspNetCore.Authentication.JwtBearer" Version="3.1.3" />
+    <PackageReference Include="Microsoft.FSharpLu" Version="0.11.6" />
+    <PackageReference Include="Microsoft.FSharpLu.Json" Version="0.11.6" />
+    <PackageReference Include="RavenDb.Client" Version="4.2.102" />
+    <PackageReference Include="TaskBuilder.fs" Version="2.1.0" />
+  </ItemGroup>
+
+  <ItemGroup>
+    <PackageReference Update="FSharp.Core" Version="4.7.1" />
+  </ItemGroup>
+
+  <ItemGroup>
+    <Folder Include="wwwroot\" />
+  </ItemGroup>
+
+</Project>

src/MyPrayerJournal.Api/Program.fs

@@ -0,0 +1,145 @@
+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 (bldr : IWebHostBuilder) =
+    bldr.UseContentRoot root
+
+  open Microsoft.Extensions.Configuration
+
+  /// Configure the application configuration
+  let appConfiguration (bldr : IWebHostBuilder) =
+    let configuration (ctx : WebHostBuilderContext) (cfg : IConfigurationBuilder) =
+      cfg.SetBasePath(ctx.HostingEnvironment.ContentRootPath)
+        .AddJsonFile("appsettings.json", optional = true, reloadOnChange = true)
+        .AddJsonFile(sprintf "appsettings.%s.json" ctx.HostingEnvironment.EnvironmentName)
+        .AddEnvironmentVariables ()
+      |> ignore
+    bldr.ConfigureAppConfiguration configuration
+    
+  open Microsoft.AspNetCore.Server.Kestrel.Core
+
+  /// Configure Kestrel from appsettings.json
+  let kestrel (bldr : IWebHostBuilder) =
+    let kestrelOpts (ctx : WebHostBuilderContext) (opts : KestrelServerOptions) =
+      (ctx.Configuration.GetSection >> opts.Configure >> ignore) "Kestrel"
+    bldr.UseKestrel().ConfigureKestrel kestrelOpts
+
+  /// Configure the web root directory
+  let webRoot pathSegments (bldr : IWebHostBuilder) =
+    (Path.Combine >> bldr.UseWebRoot) pathSegments
+
+  open Giraffe
+  open Giraffe.Serialization
+  open Microsoft.AspNetCore.Authentication.JwtBearer
+  open Microsoft.Extensions.DependencyInjection
+  open MyPrayerJournal.Indexes
+  open Newtonsoft.Json
+  open Newtonsoft.Json.Serialization
+  open Raven.Client.Documents
+  open Raven.Client.Documents.Indexes
+  open System.Security.Cryptography.X509Certificates
+
+  /// Configure dependency injection
+  let services (bldr : IWebHostBuilder) =
+    let svcs (sc : IServiceCollection) =
+      /// Custom settings for the JSON serializer (uses compact representation for options and DUs)
+      let jsonSettings =
+        let x = NewtonsoftJsonSerializer.DefaultSettings
+        Converters.all |> List.ofSeq |> List.iter x.Converters.Add
+        x.NullValueHandling     <- NullValueHandling.Ignore
+        x.MissingMemberHandling <- MissingMemberHandling.Error
+        x.Formatting            <- Formatting.Indented
+        x.ContractResolver      <- DefaultContractResolver ()
+        x
+
+      use sp  = sc.BuildServiceProvider ()
+      let cfg = sp.GetRequiredService<IConfiguration> ()
+      sc.AddGiraffe()
+        .AddAuthentication(
+          /// Use HTTP "Bearer" authentication with JWTs
+          fun opts ->
+            opts.DefaultAuthenticateScheme <- JwtBearerDefaults.AuthenticationScheme
+            opts.DefaultChallengeScheme    <- JwtBearerDefaults.AuthenticationScheme)
+        .AddJwtBearer(
+          /// Configure JWT options with Auth0 options from configuration
+          fun opts ->
+            let jwtCfg = cfg.GetSection "Auth0"
+            opts.Authority <- sprintf "https://%s/" jwtCfg.["Domain"]
+            opts.Audience  <- jwtCfg.["Id"]
+            )
+      |> ignore
+      sc.AddSingleton<IJsonSerializer> (NewtonsoftJsonSerializer jsonSettings)
+      |> ignore
+      let config = sc.BuildServiceProvider().GetRequiredService<IConfiguration>().GetSection "RavenDB"
+      let store = new DocumentStore ()
+      store.Urls        <- [| config.["URL"] |]
+      store.Database    <- config.["Database"]
+      match isNull config.["Certificate"] with
+      | true -> ()
+      | false -> store.Certificate <- new X509Certificate2 (config.["Certificate"], config.["Password"])
+      store.Conventions.CustomizeJsonSerializer <- fun x -> Converters.all |> List.ofSeq |> List.iter x.Converters.Add
+      store.Initialize () |> (sc.AddSingleton >> ignore)
+      IndexCreation.CreateIndexes (typeof<Requests_AsJournal>.Assembly, store)
+    bldr.ConfigureServices svcs
+  
+  open Microsoft.Extensions.Logging
+  open Microsoft.Extensions.Hosting
+
+  /// Configure logging
+  let logging (bldr : IWebHostBuilder) =
+    let logz (log : ILoggingBuilder) =
+      let env = log.Services.BuildServiceProvider().GetService<IWebHostEnvironment> ()
+      match env.IsDevelopment () with
+      | true -> log
+      | false -> log.AddFilter(fun l -> l > LogLevel.Information)
+      |> function l -> l.AddConsole().AddDebug()
+      |> ignore
+    bldr.ConfigureLogging logz
+
+  open System
+
+  /// Configure the web application
+  let application (bldr : IWebHostBuilder) =
+    let appConfig =
+      Action<IApplicationBuilder> (
+        fun (app : IApplicationBuilder) ->
+            let env = app.ApplicationServices.GetService<IWebHostEnvironment> ()
+            match env.IsDevelopment () with
+            | true -> app.UseDeveloperExceptionPage ()
+            | false -> app.UseGiraffeErrorHandler Handlers.Error.error
+            |> function
+            | a ->
+                a.UseAuthentication()
+                  .UseStaticFiles()
+                  .UseGiraffe Handlers.webApp
+            |> ignore)
+    bldr.Configure appConfig
+
+  /// Compose all the configurations into one
+  let webHost appRoot pathSegments =
+    contentRoot appRoot
+    >> appConfiguration
+    >> kestrel
+    >> webRoot (Array.concat [ [| appRoot |]; pathSegments ])
+    >> services
+    >> logging
+    >> application
+
+  /// Build the web host from the given configuration
+  let buildHost (bldr : IWebHostBuilder) = bldr.Build ()
+
+let exitCode = 0
+
+[<EntryPoint>]
+let main _ =
+  let appRoot = Directory.GetCurrentDirectory ()
+  use host = WebHostBuilder() |> (Configure.webHost appRoot [| "wwwroot" |] >> Configure.buildHost)
+  host.Run ()
+  exitCode

src/MyPrayerJournal.sln

@@ -0,0 +1,37 @@
+
+Microsoft Visual Studio Solution File, Format Version 12.00
+# Visual Studio Version 16
+VisualStudioVersion = 16.0.28721.148
+MinimumVisualStudioVersion = 10.0.40219.1
+Project("{6EC3EE1D-3C4E-46DD-8F32-0CC8E7565705}") = "MyPrayerJournal.Api", "MyPrayerJournal.Api\MyPrayerJournal.Api.fsproj", "{1887D1E1-544A-4F54-B266-38E7867DC842}"
+EndProject
+Global
+	GlobalSection(SolutionConfigurationPlatforms) = preSolution
+		Debug|Any CPU = Debug|Any CPU
+		Debug|iPhone = Debug|iPhone
+		Debug|iPhoneSimulator = Debug|iPhoneSimulator
+		Release|Any CPU = Release|Any CPU
+		Release|iPhone = Release|iPhone
+		Release|iPhoneSimulator = Release|iPhoneSimulator
+	EndGlobalSection
+	GlobalSection(ProjectConfigurationPlatforms) = postSolution
+		{1887D1E1-544A-4F54-B266-38E7867DC842}.Debug|Any CPU.ActiveCfg = Debug|Any CPU
+		{1887D1E1-544A-4F54-B266-38E7867DC842}.Debug|Any CPU.Build.0 = Debug|Any CPU
+		{1887D1E1-544A-4F54-B266-38E7867DC842}.Debug|iPhone.ActiveCfg = Debug|Any CPU
+		{1887D1E1-544A-4F54-B266-38E7867DC842}.Debug|iPhone.Build.0 = Debug|Any CPU
+		{1887D1E1-544A-4F54-B266-38E7867DC842}.Debug|iPhoneSimulator.ActiveCfg = Debug|Any CPU
+		{1887D1E1-544A-4F54-B266-38E7867DC842}.Debug|iPhoneSimulator.Build.0 = Debug|Any CPU
+		{1887D1E1-544A-4F54-B266-38E7867DC842}.Release|Any CPU.ActiveCfg = Release|Any CPU
+		{1887D1E1-544A-4F54-B266-38E7867DC842}.Release|Any CPU.Build.0 = Release|Any CPU
+		{1887D1E1-544A-4F54-B266-38E7867DC842}.Release|iPhone.ActiveCfg = Release|Any CPU
+		{1887D1E1-544A-4F54-B266-38E7867DC842}.Release|iPhone.Build.0 = Release|Any CPU
+		{1887D1E1-544A-4F54-B266-38E7867DC842}.Release|iPhoneSimulator.ActiveCfg = Release|Any CPU
+		{1887D1E1-544A-4F54-B266-38E7867DC842}.Release|iPhoneSimulator.Build.0 = Release|Any CPU
+	EndGlobalSection
+	GlobalSection(SolutionProperties) = preSolution
+		HideSolutionNode = FALSE
+	EndGlobalSection
+	GlobalSection(ExtensibilityGlobals) = postSolution
+		SolutionGuid = {8E2447D9-52F0-4A0D-BB61-A83C19353D7C}
+	EndGlobalSection
+EndGlobal

src/api/MyPrayerJournal.Api/Data.fs

@@ -1,283 +0,0 @@
-namespace MyPrayerJournal
-
-open FSharp.Control.Tasks.ContextInsensitive
-open Microsoft.EntityFrameworkCore
-
-/// Helpers for this file
-[<AutoOpen>]
-module private Helpers =
-  
-  /// Convert any item to an option (Option.ofObj does not work for non-nullable types)
-  let toOption<'T> (x : 'T) = match box x with null -> None | _ -> Some x
-
-
-/// Entities for use in the data model for myPrayerJournal
-[<AutoOpen>]
-module Entities =
-  
-  open FSharp.EFCore.OptionConverter
-  open System.Collections.Generic
-
-  /// Type alias for a Collision-resistant Unique IDentifier
-  type Cuid = string
-
-  /// Request ID is a CUID
-  type RequestId = Cuid
-
-  /// User ID is a string (the "sub" part of the JWT)
-  type UserId = string
-
-  /// History is a record of action taken on a prayer request, including updates to its text
-  type [<CLIMutable; NoComparison; NoEquality>] History =
-    { /// The ID of the request to which this history entry applies
-      requestId : RequestId
-      /// The time when this history entry was made
-      asOf      : int64
-      /// The status for this history entry
-      status    : string
-      /// The text of the update, if applicable
-      text      : string option
-      }
-  with
-    /// An empty history entry
-    static member empty =
-      { requestId = ""
-        asOf      = 0L
-        status    = ""
-        text      = None
-        }
-
-    static member configureEF (mb : ModelBuilder) =
-      mb.Entity<History> (
-        fun m ->
-          m.ToTable "history" |> ignore
-          m.HasKey ("requestId", "asOf") |> ignore
-          m.Property(fun e -> e.requestId).IsRequired () |> ignore
-          m.Property(fun e -> e.asOf).IsRequired () |> ignore
-          m.Property(fun e -> e.status).IsRequired() |> ignore
-          m.Property(fun e -> e.text) |> ignore)
-      |> ignore
-      let typ = mb.Model.FindEntityType(typeof<History>)
-      let prop = typ.FindProperty("text")
-      mb.Model.FindEntityType(typeof<History>).FindProperty("text").SetValueConverter (OptionConverter<string> ())
-
-  /// Note is a note regarding a prayer request that does not result in an update to its text
-  and [<CLIMutable; NoComparison; NoEquality>] Note =
-    { /// The ID of the request to which this note applies
-      requestId : RequestId
-      /// The time when this note was made
-      asOf      : int64
-      /// The text of the notes
-      notes     : string
-      }
-  with
-    /// An empty note
-    static member empty =
-      { requestId = ""
-        asOf      = 0L
-        notes     = ""
-        }
-
-    static member configureEF (mb : ModelBuilder) =
-      mb.Entity<Note> (
-        fun m ->
-          m.ToTable "note" |> ignore
-          m.HasKey ("requestId", "asOf") |> ignore
-          m.Property(fun e -> e.requestId).IsRequired () |> ignore
-          m.Property(fun e -> e.asOf).IsRequired () |> ignore
-          m.Property(fun e -> e.notes).IsRequired () |> ignore)
-      |> ignore
-
-  // Request is the identifying record for a prayer request.
-  and [<CLIMutable; NoComparison; NoEquality>] Request =
-    { /// The ID of the request
-      requestId    : RequestId
-      /// The time this request was initially entered
-      enteredOn    : int64
-      /// The ID of the user to whom this request belongs ("sub" from the JWT)
-      userId       : string
-      /// The time that this request should reappear in the user's journal
-      snoozedUntil : int64
-      /// The history entries for this request
-      history      : ICollection<History>
-      /// The notes for this request
-      notes        : ICollection<Note>
-      }
-  with
-    /// An empty request
-    static member empty =
-      { requestId    = ""
-        enteredOn    = 0L
-        userId       = ""
-        snoozedUntil = 0L
-        history      = List<History> ()
-        notes        = List<Note> ()
-        }
-
-    static member configureEF (mb : ModelBuilder) =
-      mb.Entity<Request> (
-        fun m ->
-          m.ToTable "request" |> ignore
-          m.HasKey(fun e -> e.requestId :> obj) |> ignore
-          m.Property(fun e -> e.requestId).IsRequired () |> ignore
-          m.Property(fun e -> e.enteredOn).IsRequired () |> ignore
-          m.Property(fun e -> e.userId).IsRequired () |> ignore
-          m.Property(fun e -> e.snoozedUntil).IsRequired () |> ignore
-          m.HasMany(fun e -> e.history :> IEnumerable<History>)
-            .WithOne()
-            .HasForeignKey(fun e -> e.requestId :> obj)
-          |> ignore
-          m.HasMany(fun e -> e.notes :> IEnumerable<Note>)
-            .WithOne()
-            .HasForeignKey(fun e -> e.requestId :> obj)
-          |> ignore)
-      |> ignore
-
-  /// 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
-  [<CLIMutable; NoComparison; NoEquality>]
-  type JournalRequest =
-    { /// The ID of the request
-      requestId    : RequestId
-      /// The ID of the user to whom the request belongs
-      userId       : string
-      /// The current text of the request
-      text         : string
-      /// The last time action was taken on the request
-      asOf         : int64
-      /// The last status for the request
-      lastStatus   : string
-      /// The time that this request should reappear in the user's journal
-      snoozedUntil : int64
-      /// History entries for the request
-      history      : History list
-      /// Note entries for the request
-      notes        : Note list
-      }
-  with
-    static member configureEF (mb : ModelBuilder) =
-      mb.Query<JournalRequest> (
-        fun m ->
-          m.ToView "journal" |> ignore
-          m.Ignore(fun e -> e.history :> obj) |> ignore
-          m.Ignore(fun e -> e.notes :> obj) |> ignore)
-      |> ignore
-
-
-open System.Linq
-open System.Threading.Tasks
-
-/// Data context
-type AppDbContext (opts : DbContextOptions<AppDbContext>) =
-  inherit DbContext (opts)
-
-  [<DefaultValue>]
-  val mutable private history  : DbSet<History>
-  [<DefaultValue>]
-  val mutable private notes    : DbSet<Note>
-  [<DefaultValue>]
-  val mutable private requests : DbSet<Request>
-  [<DefaultValue>]
-  val mutable private journal  : DbQuery<JournalRequest>
-
-  member this.History
-    with get () = this.history
-      and set v = this.history <- v
-  member this.Notes
-    with get () = this.notes
-      and set v = this.notes <- v
-  member this.Requests
-    with get () = this.requests
-      and set v = this.requests <- v
-  member this.Journal
-    with get () = this.journal
-      and set v = this.journal <- v
-  
-  override __.OnModelCreating (mb : ModelBuilder) =
-    base.OnModelCreating mb
-    [ History.configureEF
-      Note.configureEF
-      Request.configureEF
-      JournalRequest.configureEF
-      ]
-    |> List.iter (fun x -> x mb)
-  
-  /// Register a disconnected entity with the context, having the given state
-  member private this.RegisterAs<'TEntity when 'TEntity : not struct> state e =
-    this.Entry<'TEntity>(e).State <- state
-
-  /// Add an entity instance to the context
-  member this.AddEntry e =
-    this.RegisterAs EntityState.Added e
-
-  /// Update the entity instance's values
-  member this.UpdateEntry e =
-    this.RegisterAs EntityState.Modified e
-
-  /// Retrieve all answered requests for the given user
-  member this.AnsweredRequests userId : JournalRequest seq =
-    upcast this.Journal
-      .Where(fun r -> r.userId = userId && r.lastStatus = "Answered")
-      .OrderByDescending(fun r -> r.asOf)
-  
-  /// Retrieve the user's current journal
-  member this.JournalByUserId userId : JournalRequest seq =
-    upcast this.Journal
-      .Where(fun r -> r.userId = userId && r.lastStatus <> "Answered")
-      .OrderBy(fun r -> r.asOf)
-  
-  /// Retrieve a request by its ID and user ID
-  member this.TryRequestById reqId userId : Task<Request option> =
-    task {
-      let! req = this.Requests.AsNoTracking().FirstOrDefaultAsync(fun r -> r.requestId = reqId && r.userId = userId)
-      return toOption req
-      }
-
-  /// Retrieve notes for a request by its ID and user ID
-  member this.NotesById reqId userId =
-    task {
-      let! req = this.TryRequestById reqId userId
-      match req with
-      | Some _ -> return this.Notes.AsNoTracking().Where(fun n -> n.requestId = reqId) |> List.ofSeq
-      | None -> return []
-      }
-
-  /// Retrieve a journal request by its ID and user ID
-  member this.TryJournalById reqId userId =
-    task {
-      let! req = this.Journal.FirstOrDefaultAsync(fun r -> r.requestId = reqId && r.userId = userId)
-      return toOption req
-      }
-  
-  /// Retrieve a request, including its history and notes, by its ID and user ID
-  member this.TryCompleteRequestById requestId userId =
-    task {
-      let! req = this.TryJournalById requestId userId
-      match req with
-      | Some r ->
-          let! fullReq =
-            this.Requests.AsNoTracking()
-              .Include(fun r -> r.history)
-              .Include(fun r -> r.notes)
-              .FirstOrDefaultAsync(fun r -> r.requestId = requestId && r.userId = userId)
-          match toOption fullReq with
-          | Some _ -> return Some { r with history = List.ofSeq fullReq.history; notes = List.ofSeq fullReq.notes }
-          | None -> return None
-      | None -> return None
-      }
-  
-  /// Retrieve a request, including its history, by its ID and user ID
-  member this.TryFullRequestById requestId userId =
-    task {
-      let! req = this.TryJournalById requestId userId
-      match req with
-      | Some r ->
-          let! fullReq =
-            this.Requests.AsNoTracking()
-              .Include(fun r -> r.history)
-              .FirstOrDefaultAsync(fun r -> r.requestId = requestId && r.userId = userId)
-          match toOption fullReq with
-          | Some _ -> return Some { r with history = List.ofSeq fullReq.history }
-          | None -> return None
-      | None -> return None
-      }

src/api/MyPrayerJournal.Api/Handlers.fs

@@ -1,261 +0,0 @@
-/// HTTP handlers for the myPrayerJournal API
-[<RequireQualifiedAccess>]
-module MyPrayerJournal.Api.Handlers
-
-open Giraffe
-open MyPrayerJournal
-open System
-
-module Error =
-
-  open Microsoft.Extensions.Logging
-
-  /// Handle errors
-  let error (ex : Exception) (log : ILogger) =
-    log.LogError (EventId(), ex, "An unhandled exception has occurred while executing the request.")
-    clearResponse >=> setStatusCode 500 >=> json ex.Message
-
-  /// Handle 404s from the API, sending known URL paths to the Vue app so that they can be handled there
-  let notFound : HttpHandler =
-    fun next ctx ->
-      [ "/answered"; "/journal"; "/snoozed"; "/user" ]
-      |> List.filter ctx.Request.Path.Value.StartsWith
-      |> List.length
-      |> function
-      | 0 -> (setStatusCode 404 >=> json ([ "error", "not found" ] |> dict)) next ctx
-      | _ -> htmlFile "wwwroot/index.html" next ctx
-
-
-/// Handler helpers
-[<AutoOpen>]
-module private Helpers =
-  
-  open Microsoft.AspNetCore.Http
-  open System.Threading.Tasks
-  open System.Security.Claims
-
-  /// Get the database context from DI
-  let db (ctx : HttpContext) =
-    ctx.GetService<AppDbContext> ()
-
-  /// Get the user's "sub" claim
-  let user (ctx : HttpContext) =
-    ctx.User.Claims |> Seq.tryFind (fun u -> u.Type = ClaimTypes.NameIdentifier)
-
-  /// Get the current user's ID
-  //  NOTE: this may raise if you don't run the request through the authorize handler first
-  let userId ctx =
-    ((user >> Option.get) ctx).Value
-
-  /// Return a 201 CREATED response
-  let created next ctx =
-    setStatusCode 201 next ctx
-
-  /// The "now" time in JavaScript
-  let jsNow () =
-    DateTime.UtcNow.Subtract(DateTime (1970, 1, 1, 0, 0, 0)).TotalSeconds |> int64 |> (*) 1000L
-  
-  /// Handler to return a 403 Not Authorized reponse
-  let notAuthorized : HttpHandler =
-    setStatusCode 403 >=> fun _ _ -> Task.FromResult<HttpContext option> None
-
-  /// Handler to require authorization
-  let authorize : HttpHandler =
-    fun next ctx -> match user ctx with Some _ -> next ctx | None -> notAuthorized next ctx
-  
-  /// Flip JSON result so we can pipe into it
-  let asJson<'T> next ctx (o : 'T) =
-    json o next ctx
-
-
-/// Strongly-typed models for post requests
-module Models =
-  
-  /// A history entry addition (AKA request update)
-  [<CLIMutable>]
-  type HistoryEntry =
-    { /// The status of the history update
-      status     : string
-      /// The text of the update
-      updateText : string
-      }
-  
-  /// An additional note
-  [<CLIMutable>]
-  type NoteEntry =
-    { /// The notes being added
-      notes : string
-      }
-  
-  /// A prayer request
-  [<CLIMutable>]
-  type Request =
-    { /// The text of the request
-      requestText : string
-      }
-  
-  /// The time until which a request should not appear in the journal
-  [<CLIMutable>]
-  type SnoozeUntil =
-    { /// The time at which the request should reappear
-      until : int64
-      }
-
-
-/// /api/journal URLs
-module Journal =
-  
-  /// GET /api/journal
-  let journal : HttpHandler =
-    authorize
-    >=> fun next ctx ->
-      userId ctx
-      |> (db ctx).JournalByUserId
-      |> asJson next ctx
-
-
-/// /api/request URLs
-module Request =
-  
-  open NCuid
-  
-  /// POST /api/request
-  let add : HttpHandler =
-    authorize
-    >=> fun next ctx ->
-      task {
-        let! r     = ctx.BindJsonAsync<Models.Request> ()
-        let  db    = db ctx
-        let  reqId = Cuid.Generate ()
-        let  usrId = userId ctx
-        let  now   = jsNow ()
-        { Request.empty with
-            requestId    = reqId
-            userId       = usrId
-            enteredOn    = now
-            snoozedUntil = 0L
-          }
-        |> db.AddEntry
-        { History.empty with
-            requestId = reqId
-            asOf      = now
-            status    = "Created"
-            text      = Some r.requestText
-            }
-        |> db.AddEntry
-        let! _   = db.SaveChangesAsync ()
-        let! req = db.TryJournalById reqId usrId
-        match req with
-        | Some rqst -> return! (setStatusCode 201 >=> json rqst) next ctx
-        | None -> return! Error.notFound next ctx
-        }
-
-  /// POST /api/request/[req-id]/history
-  let addHistory reqId : HttpHandler =
-    authorize
-    >=> fun next ctx ->
-      task {
-        let  db  = db ctx
-        let! req = db.TryRequestById reqId (userId ctx)
-        match req with
-        | Some _ ->
-            let! hist = ctx.BindJsonAsync<Models.HistoryEntry> ()
-            { History.empty with
-                requestId = reqId
-                asOf      = jsNow ()
-                status    = hist.status
-                text      = match hist.updateText with null | "" -> None | x -> Some x
-              }
-            |> db.AddEntry
-            let! _ = db.SaveChangesAsync ()
-            return! created next ctx
-        | None -> return! Error.notFound next ctx
-        }
-  
-  /// POST /api/request/[req-id]/note
-  let addNote reqId : HttpHandler =
-    authorize
-    >=> fun next ctx ->
-      task {
-        let  db  = db ctx
-        let! req = db.TryRequestById reqId (userId ctx)
-        match req with
-        | Some _ ->
-            let! notes = ctx.BindJsonAsync<Models.NoteEntry> ()
-            { Note.empty with
-                requestId = reqId
-                asOf = jsNow ()
-                notes = notes.notes
-              }
-            |> db.AddEntry
-            let! _ = db.SaveChangesAsync ()
-            return! created next ctx
-        | None -> return! Error.notFound next ctx
-        }
-          
-  /// GET /api/requests/answered
-  let answered : HttpHandler =
-    authorize
-    >=> fun next ctx ->
-      userId ctx
-      |> (db ctx).AnsweredRequests
-      |> asJson next ctx
-  
-  /// GET /api/request/[req-id]
-  let get reqId : HttpHandler =
-    authorize
-    >=> fun next ctx ->
-      task {
-        let! req = (db ctx).TryJournalById reqId (userId ctx)
-        match req with
-        | Some r -> return! json r next ctx
-        | None -> return! Error.notFound next ctx
-        }
-  
-  /// GET /api/request/[req-id]/complete
-  let getComplete reqId : HttpHandler =
-    authorize
-    >=> fun next ctx ->
-      task {
-        let! req = (db ctx).TryCompleteRequestById reqId (userId ctx)
-        match req with
-        | Some r -> return! json r next ctx
-        | None -> return! Error.notFound next ctx
-        }
-  
-  /// GET /api/request/[req-id]/full
-  let getFull reqId : HttpHandler =
-    authorize
-    >=> fun next ctx ->
-      task {
-        let! req = (db ctx).TryFullRequestById reqId (userId ctx)
-        match req with
-        | Some r -> return! json r next ctx
-        | None -> return! Error.notFound next ctx
-        }
-  
-  /// GET /api/request/[req-id]/notes
-  let getNotes reqId : HttpHandler =
-    authorize
-    >=> fun next ctx ->
-      task {
-        let! notes = (db ctx).NotesById reqId (userId ctx)
-        return! json notes next ctx
-        }
-  
-  /// POST /api/request/[req-id]/snooze
-  let snooze reqId : HttpHandler =
-    authorize
-    >=> fun next ctx ->
-      task {
-        let  db  = db ctx
-        let! req = db.TryRequestById reqId (userId ctx)
-        match req with
-        | Some r ->
-            let! until = ctx.BindJsonAsync<Models.SnoozeUntil> ()
-            { r with snoozedUntil = until.until }
-            |> db.UpdateEntry
-            let! _ = db.SaveChangesAsync ()
-            return! setStatusCode 204 next ctx
-        | None -> return! Error.notFound next ctx
-        }

src/api/MyPrayerJournal.Api/MyPrayerJournal.Api.fsproj

@@ -1,30 +0,0 @@
-<Project Sdk="Microsoft.NET.Sdk.Web">
-
-  <PropertyGroup>
-    <TargetFramework>netcoreapp2.1</TargetFramework>
-  </PropertyGroup>
-
-  <ItemGroup>
-    <Compile Include="Data.fs" />
-    <Compile Include="Handlers.fs" />
-    <Compile Include="Program.fs" />
-  </ItemGroup>
-
-  <ItemGroup>
-    <PackageReference Include="FSharp.EFCore.OptionConverter" Version="1.0.0" />
-    <PackageReference Include="Giraffe" Version="1.1.0" />
-    <PackageReference Include="Giraffe.TokenRouter" Version="0.1.0-beta-110" />
-    <PackageReference Include="Microsoft.AspNetCore.App" />
-    <PackageReference Include="NCuid.NetCore" Version="1.0.1" />
-    <PackageReference Include="Npgsql.EntityFrameworkCore.PostgreSQL" Version="2.1.1.1" />
-  </ItemGroup>
-
-  <ItemGroup>
-    <PackageReference Update="FSharp.Core" Version="4.5.2" />
-  </ItemGroup>
-
-  <ItemGroup>
-    <Folder Include="wwwroot\" />
-  </ItemGroup>
-
-</Project>

src/api/MyPrayerJournal.Api/Program.fs

@@ -1,121 +0,0 @@
-namespace MyPrayerJournal.Api
-
-open Microsoft.AspNetCore.Builder
-open Microsoft.AspNetCore.Hosting
-open System
-
-
-/// Configuration functions for the application
-module Configure =
-  
-  open Giraffe
-  open Giraffe.TokenRouter
-  open Microsoft.AspNetCore.Authentication.JwtBearer
-  open Microsoft.AspNetCore.Server.Kestrel.Core
-  open Microsoft.EntityFrameworkCore
-  open Microsoft.Extensions.Configuration
-  open Microsoft.Extensions.DependencyInjection
-  open Microsoft.Extensions.Logging
-  open MyPrayerJournal
-
-  /// Set up the configuration for the app
-  let configuration (ctx : WebHostBuilderContext) (cfg : IConfigurationBuilder) =
-    cfg.SetBasePath(ctx.HostingEnvironment.ContentRootPath)
-      .AddJsonFile("appsettings.json", optional = true, reloadOnChange = true)
-      .AddJsonFile(sprintf "appsettings.%s.json" ctx.HostingEnvironment.EnvironmentName)
-      .AddEnvironmentVariables()
-    |> ignore
-    
-  /// Configure Kestrel from appsettings.json
-  let kestrel (ctx : WebHostBuilderContext) (opts : KestrelServerOptions) =
-    (ctx.Configuration.GetSection >> opts.Configure >> ignore) "Kestrel"
-
-  /// Configure dependency injection
-  let services (sc : IServiceCollection) =
-    use sp  = sc.BuildServiceProvider()
-    let cfg = sp.GetRequiredService<IConfiguration> ()
-    sc.AddGiraffe()
-      .AddAuthentication(
-        /// Use HTTP "Bearer" authentication with JWTs
-        fun opts ->
-          opts.DefaultAuthenticateScheme <- JwtBearerDefaults.AuthenticationScheme
-          opts.DefaultChallengeScheme    <- JwtBearerDefaults.AuthenticationScheme)
-      .AddJwtBearer(
-        /// Configure JWT options with Auth0 options from configuration
-        fun opts ->
-          let jwtCfg = cfg.GetSection "Auth0"
-          opts.Authority <- sprintf "https://%s/" jwtCfg.["Domain"]
-          opts.Audience  <- jwtCfg.["Id"])
-    |> ignore
-    sc.AddDbContext<AppDbContext>(fun opts -> opts.UseNpgsql(cfg.GetConnectionString "mpj") |> ignore)
-    |> ignore
-  
-  /// Routes for the available URLs within myPrayerJournal
-  let webApp =
-    router Handlers.Error.notFound [
-      subRoute "/api/" [
-        GET [
-          route    "journal" Handlers.Journal.journal
-          subRoute "request" [
-            route  "s/answered"   Handlers.Request.answered
-            routef "/%s/complete" Handlers.Request.getComplete
-            routef "/%s/full"     Handlers.Request.getFull
-            routef "/%s/notes"    Handlers.Request.getNotes
-            routef "/%s"          Handlers.Request.get
-            ]
-          ]
-        POST [
-          subRoute "request" [
-            route  ""            Handlers.Request.add
-            routef "/%s/history" Handlers.Request.addHistory
-            routef "/%s/note"    Handlers.Request.addNote
-            routef "/%s/snooze"  Handlers.Request.snooze
-            ]
-          ]
-        ]
-      ]
-
-  /// Configure the web application
-  let application (app : IApplicationBuilder) =
-    let env = app.ApplicationServices.GetService<IHostingEnvironment> ()
-    match env.IsDevelopment () with
-    | true -> app.UseDeveloperExceptionPage ()
-    | false -> app.UseGiraffeErrorHandler Handlers.Error.error
-    |> function
-    | a ->
-        a.UseAuthentication()
-          .UseStaticFiles()
-          .UseGiraffe webApp
-    |> ignore
-
-  /// Configure logging
-  let logging (log : ILoggingBuilder) =
-    let env = log.Services.BuildServiceProvider().GetService<IHostingEnvironment> ()
-    match env.IsDevelopment () with
-    | true -> log
-    | false -> log.AddFilter(fun l -> l > LogLevel.Information)
-    |> function l -> l.AddConsole().AddDebug()
-    |> ignore
-
-
-module Program =
-  
-  open System.IO
-
-  let exitCode = 0
-
-  let CreateWebHostBuilder _ =
-    let contentRoot = Directory.GetCurrentDirectory ()
-    WebHostBuilder()
-      .UseContentRoot(contentRoot)
-      .ConfigureAppConfiguration(Configure.configuration)
-      .UseKestrel(Configure.kestrel)
-      .UseWebRoot(Path.Combine (contentRoot, "wwwroot"))
-      .ConfigureServices(Configure.services)
-      .ConfigureLogging(Configure.logging)
-      .Configure(Action<IApplicationBuilder> Configure.application)
-
-  [<EntryPoint>]
-  let main args =
-    CreateWebHostBuilder(args).Build().Run()
-    exitCode

src/api/MyPrayerJournal.sln

@@ -1,25 +0,0 @@
-
-Microsoft Visual Studio Solution File, Format Version 12.00
-# Visual Studio 15
-VisualStudioVersion = 15.0.27703.2035
-MinimumVisualStudioVersion = 10.0.40219.1
-Project("{F2A71F9B-5D33-465A-A702-920D77279786}") = "MyPrayerJournal.Api", "MyPrayerJournal.Api\MyPrayerJournal.Api.fsproj", "{E0E5240C-00DC-428A-899A-DA4F06625B8A}"
-EndProject
-Global
-	GlobalSection(SolutionConfigurationPlatforms) = preSolution
-		Debug|Any CPU = Debug|Any CPU
-		Release|Any CPU = Release|Any CPU
-	EndGlobalSection
-	GlobalSection(ProjectConfigurationPlatforms) = postSolution
-		{E0E5240C-00DC-428A-899A-DA4F06625B8A}.Debug|Any CPU.ActiveCfg = Debug|Any CPU
-		{E0E5240C-00DC-428A-899A-DA4F06625B8A}.Debug|Any CPU.Build.0 = Debug|Any CPU
-		{E0E5240C-00DC-428A-899A-DA4F06625B8A}.Release|Any CPU.ActiveCfg = Release|Any CPU
-		{E0E5240C-00DC-428A-899A-DA4F06625B8A}.Release|Any CPU.Build.0 = Release|Any CPU
-	EndGlobalSection
-	GlobalSection(SolutionProperties) = preSolution
-		HideSolutionNode = FALSE
-	EndGlobalSection
-	GlobalSection(ExtensibilityGlobals) = postSolution
-		SolutionGuid = {7EAB6243-94B3-49A5-BA64-7F01B8BE7CB9}
-	EndGlobalSection
-EndGlobal

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/.browserslistrc

@@ -0,0 +1,3 @@
+> 1%
+last 2 versions
+not ie <= 8

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

src/app/.gitignore

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

src/app/.postcssrc.js

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

src/app/babel.config.js

@@ -0,0 +1,5 @@
+module.exports = {
+  presets: [
+    '@vue/app'
+  ]
+}

src/app/build/build.js

@@ -1,35 +0,0 @@
-require('./check-versions')()
-
-process.env.NODE_ENV = 'production'
-
-var ora = require('ora')
-var rm = require('rimraf')
-var path = require('path')
-var chalk = require('chalk')
-var webpack = require('webpack')
-var config = require('../config')
-var webpackConfig = require('./webpack.prod.conf')
-
-var spinner = ora('building for production...')
-spinner.start()
-
-rm(path.join(config.build.assetsRoot, config.build.assetsSubDirectory), err => {
-  if (err) throw err
-  webpack(webpackConfig, function (err, stats) {
-    spinner.stop()
-    if (err) throw err
-    process.stdout.write(stats.toString({
-      colors: true,
-      modules: false,
-      children: false,
-      chunks: false,
-      chunkModules: false
-    }) + '\n\n')
-
-    console.log(chalk.cyan('  Build complete.\n'))
-    console.log(chalk.yellow(
-      '  Tip: built files are meant to be served over an HTTP server.\n' +
-      '  Opening index.html over file:// won\'t work.\n'
-    ))
-  })
-})

src/app/build/check-versions.js

@@ -1,48 +0,0 @@
-var chalk = require('chalk')
-var semver = require('semver')
-var packageConfig = require('../package.json')
-var shell = require('shelljs')
-function exec (cmd) {
-  return require('child_process').execSync(cmd).toString().trim()
-}
-
-var versionRequirements = [
-  {
-    name: 'node',
-    currentVersion: semver.clean(process.version),
-    versionRequirement: packageConfig.engines.node
-  },
-]
-
-if (shell.which('npm')) {
-  versionRequirements.push({
-    name: 'npm',
-    currentVersion: exec('npm --version'),
-    versionRequirement: packageConfig.engines.npm
-  })
-}
-
-module.exports = function () {
-  var warnings = []
-  for (var i = 0; i < versionRequirements.length; i++) {
-    var mod = versionRequirements[i]
-    if (!semver.satisfies(mod.currentVersion, mod.versionRequirement)) {
-      warnings.push(mod.name + ': ' +
-        chalk.red(mod.currentVersion) + ' should be ' +
-        chalk.green(mod.versionRequirement)
-      )
-    }
-  }
-
-  if (warnings.length) {
-    console.log('')
-    console.log(chalk.yellow('To use this template, you must update following to modules:'))
-    console.log()
-    for (var i = 0; i < warnings.length; i++) {
-      var warning = warnings[i]
-      console.log('  ' + warning)
-    }
-    console.log()
-    process.exit(1)
-  }
-}

src/app/build/dev-client.js

@@ -1,9 +0,0 @@
-/* eslint-disable */
-require('eventsource-polyfill')
-var hotClient = require('webpack-hot-middleware/client?noInfo=true&reload=true')
-
-hotClient.subscribe(function (event) {
-  if (event.action === 'reload') {
-    window.location.reload()
-  }
-})

src/app/build/dev-server.js

@@ -1,92 +0,0 @@
-require('./check-versions')()
-
-var config = require('../config')
-if (!process.env.NODE_ENV) {
-  process.env.NODE_ENV = JSON.parse(config.dev.env.NODE_ENV)
-}
-
-var opn = require('opn')
-var path = require('path')
-var express = require('express')
-var webpack = require('webpack')
-var proxyMiddleware = require('http-proxy-middleware')
-var webpackConfig = process.env.NODE_ENV === 'testing'
-  ? require('./webpack.prod.conf')
-  : require('./webpack.dev.conf')
-
-// default port where dev server listens for incoming traffic
-var port = process.env.PORT || config.dev.port
-// automatically open browser, if not set will be false
-var autoOpenBrowser = !!config.dev.autoOpenBrowser
-// Define HTTP proxies to your custom API backend
-// https://github.com/chimurai/http-proxy-middleware
-var proxyTable = config.dev.proxyTable
-
-var app = express()
-var compiler = webpack(webpackConfig)
-
-var devMiddleware = require('webpack-dev-middleware')(compiler, {
-  publicPath: webpackConfig.output.publicPath,
-  quiet: true
-})
-
-var hotMiddleware = require('webpack-hot-middleware')(compiler, {
-  log: () => {},
-  heartbeat: 2000
-})
-// force page reload when html-webpack-plugin template changes
-compiler.plugin('compilation', function (compilation) {
-  compilation.plugin('html-webpack-plugin-after-emit', function (data, cb) {
-    hotMiddleware.publish({ action: 'reload' })
-    cb()
-  })
-})
-
-// proxy api requests
-Object.keys(proxyTable).forEach(function (context) {
-  var options = proxyTable[context]
-  if (typeof options === 'string') {
-    options = { target: options }
-  }
-  app.use(proxyMiddleware(options.filter || context, options))
-})
-
-// handle fallback for HTML5 history API
-app.use(require('connect-history-api-fallback')())
-
-// serve webpack bundle output
-app.use(devMiddleware)
-
-// enable hot-reload and state-preserving
-// compilation error display
-app.use(hotMiddleware)
-
-// serve pure static assets
-var staticPath = path.posix.join(config.dev.assetsPublicPath, config.dev.assetsSubDirectory)
-app.use(staticPath, express.static('./static'))
-
-var uri = 'http://localhost:' + port
-
-var _resolve
-var readyPromise = new Promise(resolve => {
-  _resolve = resolve
-})
-
-console.log('> Starting dev server...')
-devMiddleware.waitUntilValid(() => {
-  console.log('> Listening at ' + uri + '\n')
-  // when env is testing, don't need open it
-  if (autoOpenBrowser && process.env.NODE_ENV !== 'testing') {
-    opn(uri)
-  }
-  _resolve()
-})
-
-var server = app.listen(port)
-
-module.exports = {
-  ready: readyPromise,
-  close: () => {
-    server.close()
-  }
-}

src/app/build/utils.js

@@ -1,71 +0,0 @@
-var path = require('path')
-var config = require('../config')
-var ExtractTextPlugin = require('extract-text-webpack-plugin')
-
-exports.assetsPath = function (_path) {
-  var assetsSubDirectory = process.env.NODE_ENV === 'production'
-    ? config.build.assetsSubDirectory
-    : config.dev.assetsSubDirectory
-  return path.posix.join(assetsSubDirectory, _path)
-}
-
-exports.cssLoaders = function (options) {
-  options = options || {}
-
-  var cssLoader = {
-    loader: 'css-loader',
-    options: {
-      minimize: process.env.NODE_ENV === 'production',
-      sourceMap: options.sourceMap
-    }
-  }
-
-  // generate loader string to be used with extract text plugin
-  function generateLoaders (loader, loaderOptions) {
-    var loaders = [cssLoader]
-    if (loader) {
-      loaders.push({
-        loader: loader + '-loader',
-        options: Object.assign({}, loaderOptions, {
-          sourceMap: options.sourceMap
-        })
-      })
-    }
-
-    // Extract CSS when that option is specified
-    // (which is the case during production build)
-    if (options.extract) {
-      return ExtractTextPlugin.extract({
-        use: loaders,
-        fallback: 'vue-style-loader'
-      })
-    } else {
-      return ['vue-style-loader'].concat(loaders)
-    }
-  }
-
-  // https://vue-loader.vuejs.org/en/configurations/extract-css.html
-  return {
-    css: generateLoaders(),
-    postcss: generateLoaders(),
-    less: generateLoaders('less'),
-    sass: generateLoaders('sass', { indentedSyntax: true }),
-    scss: generateLoaders('sass'),
-    stylus: generateLoaders('stylus'),
-    styl: generateLoaders('stylus')
-  }
-}
-
-// Generate loaders for standalone style files (outside of .vue)
-exports.styleLoaders = function (options) {
-  var output = []
-  var loaders = exports.cssLoaders(options)
-  for (var extension in loaders) {
-    var loader = loaders[extension]
-    output.push({
-      test: new RegExp('\\.' + extension + '$'),
-      use: loader
-    })
-  }
-  return output
-}

src/app/build/vue-loader.conf.js

@@ -1,18 +0,0 @@
-var utils = require('./utils')
-var config = require('../config')
-var isProduction = process.env.NODE_ENV === 'production'
-
-module.exports = {
-  loaders: utils.cssLoaders({
-    sourceMap: isProduction
-      ? config.build.productionSourceMap
-      : config.dev.cssSourceMap,
-    extract: isProduction
-  }),
-  transformToRequire: {
-    video: 'src',
-    source: 'src',
-    img: 'src',
-    image: 'xlink:href'
-  }
-}

src/app/build/webpack.base.conf.js

@@ -1,75 +0,0 @@
-var path = require('path')
-var utils = require('./utils')
-var config = require('../config')
-var vueLoaderConfig = require('./vue-loader.conf')
-
-function resolve (dir) {
-  return path.join(__dirname, '..', dir)
-}
-
-module.exports = {
-  entry: {
-    app: './src/main.js'
-  },
-  output: {
-    path: config.build.assetsRoot,
-    filename: '[name].js',
-    publicPath: process.env.NODE_ENV === 'production'
-      ? config.build.assetsPublicPath
-      : config.dev.assetsPublicPath
-  },
-  resolve: {
-    extensions: ['.js', '.vue', '.json'],
-    alias: {
-      'vue$': 'vue/dist/vue.esm.js',
-      '@': resolve('src')
-    }
-  },
-  module: {
-    rules: [
-      {
-        test: /\.(js|vue)$/,
-        loader: 'eslint-loader',
-        enforce: 'pre',
-        include: [resolve('src'), resolve('test')],
-        options: {
-          formatter: require('eslint-friendly-formatter')
-        }
-      },
-      {
-        test: /\.vue$/,
-        loader: 'vue-loader',
-        options: vueLoaderConfig
-      },
-      {
-        test: /\.js$/,
-        loader: 'babel-loader',
-        include: [resolve('src'), resolve('test')]
-      },
-      {
-        test: /\.(png|jpe?g|gif|svg)(\?.*)?$/,
-        loader: 'url-loader',
-        options: {
-          limit: 10000,
-          name: utils.assetsPath('img/[name].[hash:7].[ext]')
-        }
-      },
-      {
-        test: /\.(mp4|webm|ogg|mp3|wav|flac|aac)(\?.*)?$/,
-        loader: 'url-loader',
-        options: {
-          limit: 10000,
-          name: utils.assetsPath('media/[name].[hash:7].[ext]')
-        }
-      },
-      {
-        test: /\.(woff2?|eot|ttf|otf)(\?.*)?$/,
-        loader: 'url-loader',
-        options: {
-          limit: 10000,
-          name: utils.assetsPath('fonts/[name].[hash:7].[ext]')
-        }
-      }
-    ]
-  }
-}

src/app/build/webpack.dev.conf.js

@@ -1,35 +0,0 @@
-var utils = require('./utils')
-var webpack = require('webpack')
-var config = require('../config')
-var merge = require('webpack-merge')
-var baseWebpackConfig = require('./webpack.base.conf')
-var HtmlWebpackPlugin = require('html-webpack-plugin')
-var FriendlyErrorsPlugin = require('friendly-errors-webpack-plugin')
-
-// add hot-reload related code to entry chunks
-Object.keys(baseWebpackConfig.entry).forEach(function (name) {
-  baseWebpackConfig.entry[name] = ['./build/dev-client'].concat(baseWebpackConfig.entry[name])
-})
-
-module.exports = merge(baseWebpackConfig, {
-  module: {
-    rules: utils.styleLoaders({ sourceMap: config.dev.cssSourceMap })
-  },
-  // cheap-module-eval-source-map is faster for development
-  devtool: '#cheap-module-eval-source-map',
-  plugins: [
-    new webpack.DefinePlugin({
-      'process.env': config.dev.env
-    }),
-    // https://github.com/glenjamin/webpack-hot-middleware#installation--usage
-    new webpack.HotModuleReplacementPlugin(),
-    new webpack.NoEmitOnErrorsPlugin(),
-    // https://github.com/ampedandwired/html-webpack-plugin
-    new HtmlWebpackPlugin({
-      filename: 'index.html',
-      template: 'index.html',
-      inject: true
-    }),
-    new FriendlyErrorsPlugin()
-  ]
-})

src/app/build/webpack.prod.conf.js

@@ -1,125 +0,0 @@
-var path = require('path')
-var utils = require('./utils')
-var webpack = require('webpack')
-var config = require('../config')
-var merge = require('webpack-merge')
-var baseWebpackConfig = require('./webpack.base.conf')
-var CopyWebpackPlugin = require('copy-webpack-plugin')
-var HtmlWebpackPlugin = require('html-webpack-plugin')
-var ExtractTextPlugin = require('extract-text-webpack-plugin')
-var OptimizeCSSPlugin = require('optimize-css-assets-webpack-plugin')
-
-var env = process.env.NODE_ENV === 'testing'
-  ? require('../config/test.env')
-  : config.build.env
-
-var webpackConfig = merge(baseWebpackConfig, {
-  module: {
-    rules: utils.styleLoaders({
-      sourceMap: config.build.productionSourceMap,
-      extract: true
-    }),
-    noParse: [/moment.js/]
-  },
-  devtool: config.build.productionSourceMap ? '#source-map' : false,
-  output: {
-    path: config.build.assetsRoot,
-    filename: utils.assetsPath('js/[name].[chunkhash].js'),
-    chunkFilename: utils.assetsPath('js/[id].[chunkhash].js')
-  },
-  plugins: [
-    // http://vuejs.github.io/vue-loader/en/workflow/production.html
-    new webpack.DefinePlugin({
-      'process.env': env
-    }),
-    new webpack.optimize.UglifyJsPlugin({
-      compress: {
-        warnings: false
-      },
-      sourceMap: true
-    }),
-    // extract css into its own file
-    new ExtractTextPlugin({
-      filename: utils.assetsPath('css/[name].[contenthash].css')
-    }),
-    // Compress extracted CSS. We are using this plugin so that possible
-    // duplicated CSS from different components can be deduped.
-    new OptimizeCSSPlugin({
-      cssProcessorOptions: {
-        safe: true
-      }
-    }),
-    // generate dist index.html with correct asset hash for caching.
-    // you can customize output by editing /index.html
-    // see https://github.com/ampedandwired/html-webpack-plugin
-    new HtmlWebpackPlugin({
-      filename: process.env.NODE_ENV === 'testing'
-        ? 'index.html'
-        : config.build.index,
-      template: 'index.html',
-      inject: true,
-      minify: {
-        removeComments: true,
-        collapseWhitespace: true,
-        removeAttributeQuotes: true
-        // more options:
-        // https://github.com/kangax/html-minifier#options-quick-reference
-      },
-      // necessary to consistently work with multiple chunks via CommonsChunkPlugin
-      chunksSortMode: 'dependency'
-    }),
-    // split vendor js into its own file
-    new webpack.optimize.CommonsChunkPlugin({
-      name: 'vendor',
-      minChunks: function (module, count) {
-        // any required modules inside node_modules are extracted to vendor
-        return (
-          module.resource &&
-          /\.js$/.test(module.resource) &&
-          module.resource.indexOf(
-            path.join(__dirname, '../node_modules')
-          ) === 0
-        )
-      }
-    }),
-    // extract webpack runtime and module manifest to its own file in order to
-    // prevent vendor hash from being updated whenever app bundle is updated
-    new webpack.optimize.CommonsChunkPlugin({
-      name: 'manifest',
-      chunks: ['vendor']
-    }),
-    // copy custom static assets
-    new CopyWebpackPlugin([
-      {
-        from: path.resolve(__dirname, '../static'),
-        to: config.build.assetsSubDirectory,
-        ignore: ['.*']
-      }
-    ])
-  ]
-})
-
-if (config.build.productionGzip) {
-  var CompressionWebpackPlugin = require('compression-webpack-plugin')
-
-  webpackConfig.plugins.push(
-    new CompressionWebpackPlugin({
-      asset: '[path].gz[query]',
-      algorithm: 'gzip',
-      test: new RegExp(
-        '\\.(' +
-        config.build.productionGzipExtensions.join('|') +
-        ')$'
-      ),
-      threshold: 10240,
-      minRatio: 0.8
-    })
-  )
-}
-
-if (config.build.bundleAnalyzerReport) {
-  var BundleAnalyzerPlugin = require('webpack-bundle-analyzer').BundleAnalyzerPlugin
-  webpackConfig.plugins.push(new BundleAnalyzerPlugin())
-}
-
-module.exports = webpackConfig

src/app/build/webpack.test.conf.js

@@ -1,31 +0,0 @@
-// This is the webpack config used for unit tests.
-
-var utils = require('./utils')
-var webpack = require('webpack')
-var merge = require('webpack-merge')
-var baseConfig = require('./webpack.base.conf')
-
-var webpackConfig = merge(baseConfig, {
-  // use inline sourcemap for karma-sourcemap-loader
-  module: {
-    rules: utils.styleLoaders()
-  },
-  devtool: '#inline-source-map',
-  resolveLoader: {
-    alias: {
-      // necessary to to make lang="scss" work in test when using vue-loader's ?inject option 
-      // see discussion at https://github.com/vuejs/vue-loader/issues/724
-      'scss-loader': 'sass-loader'
-    }
-  },
-  plugins: [
-    new webpack.DefinePlugin({
-      'process.env': require('../config/test.env')
-    })
-  ]
-})
-
-// no need for app entry during tests
-delete webpackConfig.entry
-
-module.exports = webpackConfig

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/MyPrayerJournal.Api/wwwroot/index.html'),
-    assetsRoot: path.resolve(__dirname, '../../api/MyPrayerJournal.Api/wwwroot'),
-    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,107 +1,36 @@
 {
   "name": "my-prayer-journal",
-  "version": "0.9.7",
+  "version": "2.1.4",
   "description": "myPrayerJournal - Front End",
   "author": "Daniel J. Summers <daniel@bitbadger.solutions>",
   "private": true,
   "scripts": {
-    "dev": "node build/dev-server.js",
+    "serve": "vue-cli-service serve --port 8081",
-    "start": "node build/dev-server.js",
+    "build": "vue-cli-service build --modern",
-    "build": "node build/build.js",
+    "lint": "vue-cli-service lint",
-    "unit": "cross-env BABEL_ENV=test karma start test/unit/karma.conf.js --single-run",
+    "apistart": "cd ../MyPrayerJournal.Api && dotnet run",
-    "e2e": "node test/e2e/runner.js",
+    "vue": "vue-cli-service build --modern && cd ../MyPrayerJournal.Api && dotnet run",
-    "test": "npm run unit && npm run e2e",
+    "publish": "vue-cli-service build --modern && cd ../MyPrayerJournal.Api && dotnet publish -c Release -r linux-x64 --self-contained false"
-    "lint": "eslint --ext .js,.vue src test/unit/specs test/e2e/specs",
-    "apistart": "cd ../api/MyPrayerJournal.Api && dotnet run",
-    "vue": "node build/build.js prod && cd ../api/MyPrayerJournal.Api && dotnet run"
   },
   "dependencies": {
-    "auth0-js": "^9.3.3",
+    "auth0-js": "^9.13.2",
-    "axios": "^0.18.0",
+    "axios": "^0.19.0",
-    "bootstrap": "^4.0.0",
-    "bootstrap-vue": "^1.0.0-beta.9",
     "moment": "^2.18.1",
-    "pug": "^2.0.1",
     "vue": "^2.5.15",
-    "vue-awesome": "^2.3.3",
+    "vue-material": "^1.0.0-beta-11",
-    "vue-progressbar": "^0.7.3",
     "vue-router": "^3.0.0",
-    "vue-toast": "^3.1.0",
+    "vuex": "^3.0.1"
-    "vuex": "^3.0.0"
   },
   "devDependencies": {
-    "autoprefixer": "^7.1.4",
+    "@vue/cli-plugin-babel": "^3.0.0",
-    "babel-core": "^6.26.0",
+    "@vue/cli-plugin-eslint": "^3.0.0",
-    "babel-eslint": "^7.1.1",
+    "@vue/cli-service": "^3.0.0",
-    "babel-loader": "^7.1.2",
+    "@vue/eslint-config-standard": "^4.0.0",
-    "babel-plugin-istanbul": "^4.1.5",
+    "node-sass": "^4.12.0",
-    "babel-plugin-transform-runtime": "^6.22.0",
+    "pug": "^2.0.1",
-    "babel-preset-env": "^1.3.2",
+    "pug-plain-loader": "^1.0.0",
-    "babel-preset-stage-2": "^6.22.0",
+    "sass-loader": "^7.3.1",
-    "babel-register": "^6.26.0",
+    "vue-template-compiler": "^2.5.17",
-    "chai": "^3.5.0",
+    "webpack-bundle-analyzer": "^3.4.1"
-    "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/public/index.html

@@ -0,0 +1,19 @@
+<!DOCTYPE html>
+<html lang="en">
+  <head>
+    <meta charset="utf-8">
+    <meta http-equiv="X-UA-Compatible" content="IE=edge">
+    <meta name="viewport" content="width=device-width,initial-scale=1.0">
+    <link rel="icon" href="<%= BASE_URL %>favicon.ico">
+    <link href="https://fonts.googleapis.com/icon?family=Material+Icons" rel="preload" as="style">
+    <link href="https://fonts.googleapis.com/icon?family=Material+Icons" rel="stylesheet">
+    <title>myPrayerJournal</title>
+  </head>
+  <body>
+    <noscript>
+      <strong>We're sorry but newapp doesn't work properly without JavaScript enabled. Please enable it to continue.</strong>
+    </noscript>
+    <div id="app"></div>
+    <!-- built files will be auto injected -->
+  </body>
+</html>

src/app/src/App.vue

@@ -1,26 +1,41 @@
 <template lang="pug">
-#app
+#app.page-container
-  navigation
+  md-app(md-waterfall md-mode='fixed-last' role='application')
-  #content.container
+    md-app-toolbar.md-large.md-dense.md-primary
-    router-view
+      .md-toolbar-row
-    vue-progress-bar
+        .md-toolbar-section-start
-    toast(ref='toast')
+          router-link(to='/').md-title
-  footer
+            span(style='font-weight:100;') my
-    p.text-right.text-muted
+            span(style='font-weight:400;') Prayer
-      | myPrayerJournal v{{ version }}
+            span(style='font-weight:700;') Journal
-      br
+      navigation
-      em: small.
+    md-app-content
-        #[router-link(:to="{ name: 'PrivacyPolicy' }") Privacy Policy] &bull;
+      md-progress-bar(v-if='progress.visible'
-        #[router-link(:to="{ name: 'TermsOfService' }") Terms of Service] &bull;
+                      :md-mode='progress.mode')
-        #[a(href='https://github.com/bit-badger/myprayerjournal') Developed] and hosted by
+      router-view
-        #[a(href='https://bitbadger.solutions') Bit Badger Solutions]
+      md-snackbar(:md-active.sync='snackbar.visible'
+                  md-position='center'
+                  :md-duration='snackbar.interval'
+                  ref='snackbar') {{ snackbar.message }}
+      footer
+        p.mpj-muted-text.mpj-text-right
+          | myPrayerJournal v{{ version }}
+          br
+          em: small.
+            #[router-link(to='/legal/privacy-policy') Privacy Policy] &bull;
+            #[router-link(to='/legal/terms-of-service') Terms of Service] &bull;
+            #[a(href='https://github.com/bit-badger/myprayerjournal' target='_blank') Developed] and hosted by
+            #[a(href='https://bitbadger.solutions' target='_blank') Bit Badger Solutions]
 </template>
 
 <script>
 'use strict'
 
-import Navigation from './components/Navigation.vue'
+import Vue from 'vue'
 
+import Navigation from '@/components/common/Navigation'
+
+import actions from '@/store/action-types'
 import { version } from '../package.json'
 
 export default {
@@ -29,44 +44,115 @@ export default {
     Navigation
   },
   data () {
-    return { version }
+    return {
+      progress: {
+        events: new Vue(),
+        visible: false,
+        mode: 'query'
+      },
+      snackbar: {
+        events: new Vue(),
+        visible: false,
+        message: '',
+        interval: 4000
+      }
+    }
   },
-  mounted () {
+  async mounted () {
-    this.$refs.toast.setOptions({ position: 'bottom right' })
+    this.progress.events.$on('show', this.showProgress)
+    this.progress.events.$on('done', this.hideProgress)
+    this.snackbar.events.$on('info', this.showInfo)
+    this.snackbar.events.$on('error', this.showError)
+    await this.$store.dispatch(actions.CHECK_AUTHENTICATION)
   },
   computed: {
-    toast () {
+    version () {
-      return this.$refs.toast
+      return version.endsWith('.0')
+        ? version.endsWith('.0.0')
+          ? version.substr(0, version.length - 4)
+          : version.substr(0, version.length - 2)
+        : version
+    }
+  },
+  methods: {
+    showSnackbar (message) {
+      this.snackbar.message = message
+      this.snackbar.visible = true
+    },
+    showInfo (message) {
+      this.snackbar.interval = 4000
+      this.showSnackbar(message)
+    },
+    showError (message) {
+      this.snackbar.interval = Infinity
+      this.showSnackbar(message)
+    },
+    showProgress (mode) {
+      this.progress.mode = mode
+      this.progress.visible = true
+    },
+    hideProgress () {
+      this.progress.visible = false
+    },
+    handleLoginEvent (data) {
+      if (!data.loggedIn) {
+        this.showInfo('Logged out successfully')
+      }
+    }
+  },
+  provide () {
+    return {
+      messages: this.snackbar.events,
+      progress: this.progress.events
     }
   }
 }
 </script>
 
-<style>
+<style lang="sass">
-html, body {
+@import "~vue-material/dist/theme/engine"
-  background-color: whitesmoke;
+@include md-register-theme("default", (primary: md-get-palette-color(green, 800), accent: md-get-palette-color(gray, 700)))
-}
+@import "~vue-material/dist/theme/all"
-body {
+
-  padding-top: 60px;
+html, body
-}
+  font-family: -apple-system,BlinkMacSystemFont,"Segoe UI",Roboto,Oxygen-Sans,Ubuntu,Cantarell,"Helvetica Neue",sans-serif;
-footer {
+  font-size: 1rem
-  border-top: solid 1px lightgray;
+p
-  margin-top: 1rem;
+  margin-bottom: 0
-  padding: 0 1rem;
+footer
-}
+  border-top: solid 1px lightgray
-footer p {
+  margin: 1rem -1rem 0
-  margin: 0;
+  padding: 0 1rem
-}
+footer p
-a:link, a:visited {
+  margin: 0
-  color: #050;
+.mpj-full-page-card
-}
+  font-size: 1rem
-.mpj-request-text {
+  line-height: 1.25rem
-  white-space: pre-line;
+.mpj-main-content
-}
+  max-width: 60rem
-.bg-mpj {
+  margin: auto
-  background-image: -webkit-gradient(linear, left top, left bottom, from(#050), to(whitesmoke));
+.mpj-request-text
-  background-image: -webkit-linear-gradient(top, #050, whitesmoke);
+  white-space: pre-line
-  background-image: -moz-linear-gradient(top, #050, whitesmoke);
+p.mpj-request-text
-  background-image: linear-gradient(to bottom, #050, whitesmoke);
+  margin-top: 0
-}
+.mpj-text-center
+  text-align: center
+.mpj-text-nowrap
+  white-space: nowrap
+.mpj-text-right
+  text-align: right
+.mpj-muted-text
+  color: rgba(0, 0, 0, .6)
+.mpj-valign-top
+  vertical-align: top
+.mpj-narrow
+  max-width: 40rem
+  margin: auto
+.mpj-skinny
+  max-width: 20rem
+  margin: auto
+.mpj-full-width
+  width: 100%
+.md-progress-bar
+  margin: 24px
 </style>

src/app/src/api/index.js

@@ -1,3 +1,5 @@
+'use strict'
+
 import axios from 'axios'
 
 const http = axios.create({
@@ -13,12 +15,12 @@ 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}` },
+  setBearer: token => { http.defaults.headers.common['Authorization'] = `Bearer ${token}` },
 
   /**
    * Remove the bearer token
    */
-  removeBearer: () => delete http.defaults.headers.common['authorization'],
+  removeBearer: () => delete http.defaults.headers.common['Authorization'],
 
   /**
    * Add a note for a prayer request
@@ -30,8 +32,10 @@ export default {
   /**
    * Add a new prayer request
    * @param {string} requestText The text of the request to be added
+   * @param {string} recurType The type of recurrence for this request
+   * @param {number} recurCount The number of intervals of recurrence
    */
-  addRequest: requestText => http.post('request', { requestText }),
+  addRequest: (requestText, recurType, recurCount) => http.post('request', { requestText, recurType, recurCount }),
 
   /**
    * Get all answered requests, along with the text they had when it was answered
@@ -39,7 +43,7 @@ export default {
   getAnsweredRequests: () => http.get('requests/answered'),
 
   /**
-   * Get a prayer request (full; includes all history)
+   * Get a prayer request (full; includes all history and notes)
    * @param {string} requestId The Id of the request to retrieve
    */
   getFullRequest: requestId => http.get(`request/${requestId}/full`),
@@ -56,30 +60,39 @@ export default {
    */
   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'),
 
   /**
-   * Snooze a request until the given time
+   * Show a request after the given date (used for "show now")
-   * @param requestId {string} The ID of the prayer request to be snoozed
+   * @param {string} requestId The ID of the request which should be shown
-   * @param until {number} The ticks until which the request should be snoozed
+   * @param {number} showAfter The ticks after which the request should be shown
    */
-  snoozeRequest: (requestId, until) => http.post(`request/${requestId}/snooze`, { until }),
+  showRequest: (requestId, showAfter) => http.patch(`request/${requestId}/show`, { showAfter }),
+
+  /**
+   * Snooze a request until the given time
+   * @param {string} requestId The ID of the prayer request to be snoozed
+   * @param {number} until The ticks until which the request should be snoozed
+   */
+  snoozeRequest: (requestId, until) => http.patch(`request/${requestId}/snooze`, { until }),
+
+  /**
+   * Update recurrence for a prayer request
+   * @param {string} requestId The ID of the prayer request for which recurrence is being updated
+   * @param {string} recurType The type of recurrence to set
+   * @param {number} recurCount The number of recurrence intervals to set
+   */
+  updateRecurrence: (requestId, recurType, recurCount) =>
+    http.patch(`request/${requestId}/recurrence`, { recurType, recurCount }),
 
   /**
    * Update a prayer request
-   * @param request The request (should have requestId, status, and updateText properties)
+   * @param {string} requestId The ID of the request to be updated
+   * @param {string} status The status of the update
+   * @param {string} updateText The text of the update (optional)
    */
-  updateRequest: request => http.post(`request/${request.requestId}/history`, {
+  updateRequest: (requestId, status, updateText) => http.post(`request/${requestId}/history`, { status, updateText })
-    status: request.status,
-    updateText: request.updateText
-  })
-
 }

src/app/src/auth/AuthService.js

@@ -1,32 +1,45 @@
 'use strict'
-
+/* eslint-disable */
-import auth0 from 'auth0-js'
+import auth0        from 'auth0-js'
+import EventEmitter from 'events'
 
 import AUTH_CONFIG from './auth0-variables'
-import mutations from '@/store/mutation-types'
+import mutations   from '@/store/mutation-types'
+/* es-lint-enable*/
 
-var tokenRenewalTimeout
+// Auth0 web authentication instance to use for our calls
+const webAuth = 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'
+})
 
-export default class AuthService {
+/**
+ * A class to handle all authentication calls and determinations
+ */
+class AuthService extends EventEmitter {
   
-  constructor () {
+  // Local storage key for our session data
-    this.login = this.login.bind(this)
+  AUTH_SESSION = 'auth-session'
-    this.setSession = this.setSession.bind(this)
+
-    this.logout = this.logout.bind(this)
+  // Received and calculated values for our ssesion (initially loaded from local storage if present)
-    this.isAuthenticated = this.isAuthenticated.bind(this)
+  session = {}
+
+  constructor() {
+    super()
+    this.refreshSession()
   }
 
-  auth0 = new auth0.WebAuth({
+  /**
-    domain: AUTH_CONFIG.domain,
+   * Starts the user log in flow
-    clientID: AUTH_CONFIG.clientId,
+   */
-    redirectUri: AUTH_CONFIG.appDomain + AUTH_CONFIG.callbackUrl,
+  login (customState) {
-    audience: `https://${AUTH_CONFIG.domain}/userinfo`,
+    webAuth.authorize({
-    responseType: 'token id_token',
+      appState: customState
-    scope: 'openid profile email'
+    })
-  })
-
-  login () {
-    this.auth0.authorize()
   }
 
   /**
@@ -34,7 +47,7 @@ export default class AuthService {
    */
   parseHash () {
     return new Promise((resolve, reject) => {
-      this.auth0.parseHash((err, authResult) => {
+      webAuth.parseHash((err, authResult) => {
         if (err) {
           reject(err)
         } else {
@@ -45,95 +58,137 @@ export default class AuthService {
   }
 
   /**
-   * Promisified userInfo function
+   * Handle authentication replies from Auth0
    * 
-   * @param token The auth token from the login result
+   * @param store The Vuex store
    */
-  userInfo (token) {
+  async handleAuthentication (store) {
-    return new Promise((resolve, reject) => {
+    try {
-      this.auth0.client.userInfo(token, (err, user) => {
+      const authResult = await this.parseHash()
-        if (err) {
+      if (authResult && authResult.accessToken && authResult.idToken) {
-          reject(err)
+        this.setSession(authResult)
-        } else {
+        store.commit(mutations.USER_LOGGED_ON, this.session.profile)
-          resolve(user)
+      }
-        }
+    } catch(err) {
-      })
+      console.error(err)
-    })
+      alert(`Error: ${err.error}. Check the console for further details.`)
-  }
-
-  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)
     }
   }
 
+  /**
+   * Set up the session and commit it to local storage
+   * 
+   * @param authResult The authorization result
+   */
   setSession (authResult) {
-    // Set the time that the access token will expire at
+    this.session.profile = authResult.idTokenPayload
-    let expiresAt = JSON.stringify(
+    this.session.id.token = authResult.idToken
-      authResult.expiresIn * 1000 + new Date().getTime()
+    this.session.id.expiry = this.session.profile.exp * 1000
-    )
+    this.session.access.token = authResult.accessToken
-    localStorage.setItem('access_token', authResult.accessToken)
+    this.session.access.expiry = authResult.expiresIn * 1000 + Date.now()
-    localStorage.setItem('id_token', authResult.idToken)
+
-    localStorage.setItem('expires_at', expiresAt)
+    localStorage.setItem(this.AUTH_SESSION, JSON.stringify(this.session))
-    this.scheduleRenewal()
+
+    this.emit('loginEvent', {
+      loggedIn: true,
+      profile: authResult.idTokenPayload,
+      state: authResult.appState || {}
+    })
   }
 
-  renewToken () {
+  /**
-    console.log('attempting renewal...')
+   * Refresh this instance's session from the one in local storage
-    this.auth0.renewAuth(
+   */
-      {
+  refreshSession () {
-        audience: `https://${AUTH_CONFIG.domain}/userinfo`,
+    this.session = 
-        redirectUri: `${AUTH_CONFIG.appDomain}/static/silent.html`,
+      localStorage.getItem(this.AUTH_SESSION)
-        usePostMessage: true
+      ? JSON.parse(localStorage.getItem(this.AUTH_SESSION))
-      },
+      : { profile: {},
-      (err, result) => {
+          id: {
-        if (err) {
+            token: null,
-          console.log(err)
+            expiry: null
-        } else {
+          },
-          this.setSession(result)
+          access: {
+            token: null,
+            expiry: null
+          }
         }
+  }
+
+  /**
+   * Renew authorzation tokens with Auth0
+   */
+  renewTokens () {
+    return new Promise((resolve, reject) => {
+      this.refreshSession()
+      if (this.session.id.token !== null) {
+        webAuth.checkSession({}, (err, authResult) => {
+          if (err) {
+            reject(err)
+          } else {
+            this.setSession(authResult)
+            resolve(authResult)
+          }
+        })
+      } else {
+        reject('Not logged in')
       }
-    )
+    })
   }
 
-  logout (store, router) {
+  /**
+   * Log out of myPrayerJournal
+   * 
+   * @param store The Vuex store
+   */
+  logout (store) {
     // Clear access token and ID token from local storage
-    clearTimeout(tokenRenewalTimeout)
+    localStorage.removeItem(this.AUTH_SESSION)
-    localStorage.removeItem('access_token')
+    this.refreshSession()
-    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('/')
+
+    webAuth.logout({
+      returnTo: `${AUTH_CONFIG.appDomain}/`,
+      clientID: AUTH_CONFIG.clientId
+    })
+    this.emit('loginEvent', { loggedIn: false })
   }
 
+  /**
+   * Check expiration for a token (the way it's stored in the session)
+   */
+  checkExpiry = (it) => it.token && it.expiry && Date.now() < it.expiry
+  
+  /**
+   * Is there a user authenticated?
+   */
   isAuthenticated () {
-    // Check whether the current time is past the access token's expiry time
+    return this.checkExpiry(this.session.id)
-    let expiresAt = JSON.parse(localStorage.getItem('expires_at'))
+  }
-    return new Date().getTime() < expiresAt
+
+  /**
+   * Is the current access token valid?
+   */
+  isAccessTokenValid () {
+    return this.checkExpiry(this.session.access)
+  }
+
+  /**
+   * Get the user's access token, renewing it if required
+   */
+  async getAccessToken () {
+    if (this.isAccessTokenValid()) {
+      return this.session.access.token
+    } else {
+      try {
+        const authResult = await this.renewTokens()
+        return authResult.accessToken
+      } catch (reject) {
+        throw reject
+      }
+    }
   }
 }
+
+export default new AuthService()

src/app/src/components/Answered.vue

@@ -1,63 +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.text-center(v-if='requests.length === 0'): em.
-      No answered requests found; once you have marked one as &ldquo;Answered&rdquo;, it will appear here
-    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,83 +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(slot='text' scope='data' v-if='data.item.text') {{ data.item.text.fields[0] }}
-</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.fields[0]
-    },
-    log () {
-      return (this.request.notes || [])
-        .map(note => ({ asOf: note.asOf, text: { case: 'Some', fields: [ 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,16 +1,16 @@
 <template lang="pug">
-article
+md-content(role='main').mpj-main-content
   page-title(title='Welcome!'
-             hideOnPage='true')
+             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
+    update them as God moves in the situation, and record a final answer received on that request. It also allows
     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
+    This site is open and available to the general public. To get started, simply click the &ldquo;Log On&rdquo; link
-    the &ldquo;Log On&rdquo; link above, and log on with either a Microsoft or Google account. You can also learn more
+    above, and log on with either a Microsoft or Google account. You can also learn more about the site at the
-    about the site at the &ldquo;Docs&rdquo; link, also above.
+    &ldquo;Docs&rdquo; link, also above.
 </template>
 
 <script>

src/app/src/components/Journal.vue

@@ -1,25 +1,24 @@
 <template lang="pug">
-article
+md-content(role='main').mpj-main-content-wide
   page-title(:title='title')
   p(v-if='isLoadingJournal') Loading your prayer journal...
-  template(v-if='!isLoadingJournal')
+  template(v-else)
-    new-request
+    md-empty-state(v-if='journal.length === 0'
-    br
+                   md-icon='done_all'
-    b-row(v-if='journal.length > 0')
+                   md-label='No Requests to Show'
-      request-card(v-for='request in journal'
+                   md-description='You have no requests to be shown; see the “Active” link above for snoozed/deferred requests, and the “Answered” link for answered requests')
-                   :key='request.requestId'
+      md-button(:to="{ name: 'EditRequest', params: { id: 'new' } }").md-primary.md-raised Add a New Request
-                   :request='request'
+    template(v-else)
-                   :events='eventBus'
+      .mpj-text-center
-                   :toast='toast')
+        md-button(:to="{ name: 'EditRequest', params: { id: 'new' } }"
-    p.text-center(v-if='journal.length === 0'): em.
+                  role='button').md-raised.md-accent #[md-icon add_box] Add a New Request
-      No requests found; click the &ldquo;Add a New Request&rdquo; button to add one
+      br
-    edit-request(:events='eventBus'
+      .mpj-journal
-                 :toast='toast')
+        request-card(v-for='request in journal'
-    notes-edit(:events='eventBus'
+                    :key='request.requestId'
-               :toast='toast')
+                    :request='request')
-    full-request(:events='eventBus')
+    notes-edit
-    snooze-request(:events='eventBus'
+    snooze-request
-                   :toast='toast')
 </template>
 
 <script>
@@ -28,9 +27,6 @@ article
 import Vue from 'vue'
 import { mapState } from 'vuex'
 
-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 SnoozeRequest from './request/SnoozeRequest'
@@ -39,10 +35,11 @@ import actions from '@/store/action-types'
 
 export default {
   name: 'journal',
+  inject: [
+    'messages',
+    'progress'
+  ],
   components: {
-    EditRequest,
-    FullRequest,
-    NewRequest,
     NotesEdit,
     RequestCard,
     SnoozeRequest
@@ -56,14 +53,29 @@ export default {
     title () {
       return `${this.user.given_name}&rsquo;s Prayer Journal`
     },
-    toast () {
+    snackbar () {
-      return this.$parent.$refs.toast
+      return this.$parent.$refs.snackbar
     },
     ...mapState(['user', 'journal', 'isLoadingJournal'])
   },
   async created () {
-    await this.$store.dispatch(actions.LOAD_JOURNAL, this.$Progress)
+    await this.$store.dispatch(actions.LOAD_JOURNAL, this.progress)
-    this.toast.showToast(`Loaded ${this.journal.length} prayer requests`, { theme: 'success' })
+    this.messages.$emit('info', `Loaded ${this.journal.length} prayer requests`)
+  },
+  provide () {
+    return {
+      journalEvents: this.eventBus
+    }
   }
 }
 </script>
+
+<style lang="sass">
+.mpj-journal
+  display: flex
+  flex-flow: row wrap
+  justify-content: center
+  align-items: flex-start
+.mpj-dialog-content
+  padding: 0 1rem
+</style>

src/app/src/components/Navigation.vue

@@ -1,56 +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-navbar-nav
-      b-nav-item(v-if='isAuthenticated'
-                 to='/journal') Journal
-      b-nav-item(v-if='hasSnoozed'
-                 to='/snoozed') Snoozed
-      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://bit-badger.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: {
-    hasSnoozed () {
-      return this.isAuthenticated &&
-        Array.isArray(this.journal) &&
-        this.journal.filter(req => req.snoozedUntil > Date.now()).length > 0
-    },
-    ...mapState([ 'journal', 'isAuthenticated' ])
-  },
-  methods: {
-    logOn () {
-      this.auth0.login()
-    },
-    logOff () {
-      this.auth0.logout(this.$store, this.$router)
-    }
-  }
-}
-</script>

src/app/src/components/Snoozed.vue

@@ -1,76 +0,0 @@
-<template lang="pug">
-article
-  page-title(title='Snoozed Requests')
-  p(v-if='!loaded') Loading journal...
-  div(v-if='loaded').mpj-snoozed-list
-    p.text-center(v-if='requests.length === 0'): em.
-      No snoozed requests found; return to #[router-link(:to='{ name: "Journal" } ') your journal]
-    p.mpj-snoozed-text(v-for='req in requests' :key='req.requestId')
-      | {{ req.text }}
-      br
-      br
-      b-btn(@click='cancelSnooze(req.requestId)'
-            size='sm'
-            variant='outline-secondary')
-        icon(name='times')
-        = ' Cancel Snooze'
-      small.text-muted: em.
-        &nbsp; Snooze expires #[date-from-now(:value='req.snoozedUntil')]
-</template>
-
-<script>
-'use static'
-
-import { mapState } from 'vuex'
-
-import actions from '@/store/action-types'
-
-export default {
-  name: 'answered',
-  data () {
-    return {
-      requests: [],
-      loaded: false
-    }
-  },
-  computed: {
-    toast () {
-      return this.$parent.$refs.toast
-    },
-    ...mapState(['journal', 'isLoadingJournal'])
-  },
-  methods: {
-    async ensureJournal () {
-      if (!Array.isArray(this.journal)) {
-        this.loaded = false
-        await this.$store.dispatch(actions.LOAD_JOURNAL, this.$Progress)
-      }
-      this.requests = this.journal
-        .filter(req => req.snoozedUntil > Date.now())
-        .sort((a, b) => a.snoozedUntil - b.snoozedUntil)
-      this.loaded = true
-    },
-    async cancelSnooze (requestId) {
-      await this.$store.dispatch(actions.SNOOZE_REQUEST, {
-        progress: this.$Progress,
-        requestId: requestId,
-        until: 0
-      })
-      this.toast.showToast('Request un-snoozed', { theme: 'success' })
-      this.ensureJournal()
-    }
-  },
-  async mounted () {
-    await this.ensureJournal()
-  }
-}
-</script>
-
-<style>
-.mpj-snoozed-list p {
-  border-top: solid 1px lightgray;
-}
-.mpj-snoozed-list p:first-child {
-  border-top: none;
-}
-</style>

src/app/src/components/common/Navigation.vue

@@ -0,0 +1,59 @@
+<template lang="pug">
+.md-toolbar-row
+  md-tabs(md-sync-route).md-primary
+    template(v-if='isAuthenticated')
+      md-tab(md-label='Journal'
+             to='/journal')
+      md-tab(md-label='Active'
+             to='/requests/active')
+      md-tab(v-if='hasSnoozed'
+             md-label='Snoozed'
+             to='/requests/snoozed')
+      md-tab(md-label='Answered'
+             to='/requests/answered')
+      md-tab(md-label='Log Off'
+             href='/user/log-off'
+             @click.prevent='logOff()')
+      md-tab(md-label='Docs'
+             href='https://docs.prayerjournal.me'
+             @click.prevent='showHelp()')
+    template(v-else)
+      md-tab(md-label='Log On'
+             href='/user/log-on'
+             @click.prevent='logOn()')
+      md-tab(md-label='Docs'
+             href='https://docs.prayerjournal.me'
+             @click.prevent='showHelp()')
+</template>
+
+<script>
+'use strict'
+
+import { mapState } from 'vuex'
+
+export default {
+  name: 'navigation',
+  data () {
+    return {}
+  },
+  computed: {
+    hasSnoozed () {
+      return this.isAuthenticated &&
+        Array.isArray(this.journal) &&
+        this.journal.filter(req => req.snoozedUntil > Date.now()).length > 0
+    },
+    ...mapState([ 'isAuthenticated', 'journal' ])
+  },
+  methods: {
+    logOn () {
+      this.$auth.login()
+    },
+    logOff () {
+      this.$auth.logout(this.$store, this.$router)
+    },
+    showHelp () {
+      window.open('https://docs.prayerjournal.me', '_blank')
+    }
+  }
+}
+</script>

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

@@ -1,6 +1,6 @@
 <template lang="pug">
-h2.mpj-page-title(v-if='!hideOnPage'
+h1(v-if='!hideOnPage'
-                  v-html='title')
+   v-html='title').md-title
 </template>
 
 <script>
@@ -26,10 +26,3 @@ export default {
   }
 }
 </script>
-
-<style scoped>
-.mpj-page-title {
-  border-bottom: solid 1px lightgray;
-  margin-bottom: 20px;
-}
-</style>

src/app/src/components/legal/PrivacyPolicy.vue

@@ -1,54 +1,59 @@
 <template lang="pug">
-article
+md-content(role='main').mpj-main-content
-  page-title(title='Privacy Policy')
+  page-title(title='Privacy Policy'
-  p: small: em (as of May 21, 2018)
+             hide-on-page=true)
-  p.
+  md-card
-    The nature of the service is one where privacy is a must. The items below will help you understand the data we
+    md-card-header
-    collect, access, and store on your behalf as you use this service.
+      .md-title Privacy Policy
-  hr
+      .md-subhead as of May 21, 2018
-  h3 Third Party Services
+    md-card-content.mpj-full-page-card
-  p.
+      p.
-    myPrayerJournal utilizes a third-party authentication and identity provider. You should familiarize yourself with
+        The nature of the service is one where privacy is a must. The items below will help you understand the data we
-    the privacy policy for #[a(href='https://auth0.com/privacy' target='_blank') Auth0], as well as your chosen provider
+        collect, access, and store on your behalf as you use this service.
-    (#[a(href='https://privacy.microsoft.com/en-us/privacystatement' target='_blank') Microsoft] or
+      hr
-    #[a(href='https://policies.google.com/privacy' target='_blank') Google]).
+      h3 Third Party Services
-  hr
+      p.
-  h3 What We Collect
+        myPrayerJournal utilizes a third-party authentication and identity provider. You should familiarize yourself
-  h4 Identifying Data
+        with the privacy policy for #[a(href='https://auth0.com/privacy' target='_blank') Auth0], as well as your
-  ul
+        chosen provider (#[a(href='https://privacy.microsoft.com/en-us/privacystatement' target='_blank') Microsoft] or
-    li.
+        #[a(href='https://policies.google.com/privacy' target='_blank') Google]).
-      The only identifying data myPrayerJournal stores is the subscriber (&ldquo;sub&rdquo;) field from the token we
+      hr
-      receive from Auth0, once you have signed in through their hosted service. All information is associated with you
+      h3 What We Collect
-      via this field.
+      h4 Identifying Data
-    li.
+      ul
-      While you are signed in, within your browser, the service has access to your first and last names, along with a
+        li.
-      URL to the profile picture (provided by your selected identity provider). This information is not transmitted to
+          The only identifying data myPrayerJournal stores is the subscriber (&ldquo;sub&rdquo;) field from the token we
-      the server, and is removed when &ldquo;Log Off&rdquo; is clicked.
+          receive from Auth0, once you have signed in through their hosted service. All information is associated with
-  h4 User Provided Data
+          you via this field.
-  ul
+        li.
-    li.
+          While you are signed in, within your browser, the service has access to your first and last names, along with
-      myPrayerJournal stores the information you provide, including the text of prayer requests, updates, and notes;
+          a URL to the profile picture (provided by your selected identity provider). This information is not
-      and the date/time when certain actions are taken.
+          transmitted to the server, and is removed when &ldquo;Log Off&rdquo; is clicked.
-  hr
+      h4 User Provided Data
-  h3 How Your Data Is Accessed / Secured
+      ul
-  ul
+        li.
-    li.
+          myPrayerJournal stores the information you provide, including the text of prayer requests, updates, and notes;
-      Your provided data is returned to you, as required, to display your journal or your answered requests.
+          and the date/time when certain actions are taken.
-      On the server, it is stored in a controlled-access database.
+      hr
-    li.
+      h3 How Your Data Is Accessed / Secured
-      Your data is backed up, along with other Bit Badger Solutions hosted systems, in a rolling manner; backups are
+      ul
-      preserved for the prior 7 days, and backups from the 1st and 15th are preserved for 3 months. These backups are
+        li.
-      stored in a private cloud data repository.
+          Your provided data is returned to you, as required, to display your journal or your answered requests. On the
-    li.
+          server, it is stored in a controlled-access database.
-      The data collected and stored is the absolute minimum necessary for the functionality of the service. There are
+        li.
-      no plans to &ldquo;monetize&rdquo; this service, and storing the minimum amount of information means that the
+          Your data is backed up, along with other Bit Badger Solutions hosted systems, in a rolling manner; backups are
-      data we have is not interesting to purchasers (or those who may have more nefarious purposes).
+          preserved for the prior 7 days, and backups from the 1st and 15th are preserved for 3 months. These backups
-    li Access to servers and backups is strictly controlled and monitored for unauthorized access attempts.
+          are stored in a private cloud data repository.
-  hr
+        li.
-  h3 Removing Your Data
+          The data collected and stored is the absolute minimum necessary for the functionality of the service. There
-  p.
+          are no plans to &ldquo;monetize&rdquo; this service, and storing the minimum amount of information means that
-    At any time, you may choose to discontinue using this service. Both Microsoft and Google provide ways to revoke
+          the data we have is not interesting to purchasers (or those who may have more nefarious purposes).
-    access from this application. However, if you want your data removed from the database, please contact daniel at
+        li Access to servers and backups is strictly controlled and monitored for unauthorized access attempts.
-    bitbadger.solutions (via e-mail, replacing at with @) prior to doing so, to ensure we can determine which
+      hr
-    subscriber ID belongs to you.
+      h3 Removing Your Data
+      p.
+        At any time, you may choose to discontinue using this service. Both Microsoft and Google provide ways to revoke
+        access from this application. However, if you want your data removed from the database, please contact daniel at
+        bitbadger.solutions (via e-mail, replacing at with @) prior to doing so, to ensure we can determine which
+        subscriber ID belongs to you.
 </template>

src/app/src/components/legal/TermsOfService.vue

@@ -1,35 +1,40 @@
 <template lang="pug">
-article
+md-content(role='main').mpj-main-content
-  page-title(title='Terms of Service')
+  page-title(title='Terms of Service'
-  p: small: em (as of May 21, 2018)
+             hide-on-page=true)
-  h3 1. Acceptance of Terms
+  md-card
-  p.
+    md-card-header
-    By accessing this web site, you are agreeing to be bound by these Terms and Conditions, and that you are
+      .md-title Terms of Service
-    responsible to ensure that your use of this site complies with all applicable laws. Your continued use of this
+      .md-subhead as of May 21, 2018
-    site implies your acceptance of these terms.
+    md-card-content.mpj-full-page-card
-  h3 2. Description of Service and Registration
+      h3 1. Acceptance of Terms
-  p.
+      p.
-    myPrayerJournal is a service that allows individuals to enter and amend their prayer requests. It requires no
+        By accessing this web site, you are agreeing to be bound by these Terms and Conditions, and that you are
-    registration by itself, but access is granted based on a successful login with an external identity provider. See
+        responsible to ensure that your use of this site complies with all applicable laws. Your continued use of this
-    #[router-link(:to="{ name: 'PrivacyPolicy' }") our privacy policy] for details on how that information is accessed
+        site implies your acceptance of these terms.
-    and stored.
+      h3 2. Description of Service and Registration
-  h3 3. Third Party Services
+      p.
-  p.
+        myPrayerJournal is a service that allows individuals to enter and amend their prayer requests. It requires no
-    This service utilizes a third-party service provider for identity management. Review the terms of service for
+        registration by itself, but access is granted based on a successful login with an external identity provider.
-    #[a(href='https://auth0.com/terms' target='_blank') Auth0], as well as those for the selected authorization
+        See #[router-link(:to="{ name: 'PrivacyPolicy' }") our privacy policy] for details on how that information is
-    provider (#[a(href='https://www.microsoft.com/en-us/servicesagreement' target='_blank') Microsoft] or
+        accessed and stored.
-    #[a(href='https://policies.google.com/terms' target='_blank') Google]).
+      h3 3. Third Party Services
-  h3 4. Liability
+      p.
-  p.
+        This service utilizes a third-party service provider for identity management. Review the terms of service for
-    This service is provided "as is", and no warranty (express or implied) exists. The service and its developers may
+        #[a(href='https://auth0.com/terms' target='_blank') Auth0], as well as those for the selected authorization
-    not be held liable for any damages that may arise through the use of this service.
+        provider (#[a(href='https://www.microsoft.com/en-us/servicesagreement' target='_blank') Microsoft] or
-  h3 5. Updates to Terms
+        #[a(href='https://policies.google.com/terms' target='_blank') Google]).
-  p.
+      h3 4. Liability
-    These terms and conditions may be updated at any time, and this service does not have the capability to notify
+      p.
-    users when these change. The date at the top of the page will be updated when any of the text of these terms is
+        This service is provided "as is", and no warranty (express or implied) exists. The service and its developers
-    updated.
+        may not be held liable for any damages that may arise through the use of this service.
-  hr
+      h3 5. Updates to Terms
-  p.
+      p.
-    You may also wish to review our #[router-link(:to="{ name: 'PrivacyPolicy' }") privacy policy] to learn how we
+        These terms and conditions may be updated at any time, and this service does not have the capability to notify
-    handle your data.
+        users when these change. The date at the top of the page will be updated when any of the text of these terms is
+        updated.
+      hr
+      p.
+        You may also wish to review our #[router-link(:to="{ name: 'PrivacyPolicy' }") privacy policy] to learn how we
+        handle your data.
 </template>

src/app/src/components/request/ActiveRequests.vue

@@ -0,0 +1,60 @@
+<template lang="pug">
+md-content(role='main').mpj-main-content
+  page-title(title='Active Requests'
+             hide-on-page=true)
+  template(v-if='loaded')
+    md-empty-state(v-if='requests.length === 0'
+                   md-icon='sentiment_dissatisfied'
+                   md-label='No Active Requests'
+                   md-description='Your prayer journal has no active requests')
+      md-button(to='/journal').md-primary.md-raised Return to your journal
+    request-list(v-if='requests.length !== 0'
+                 title='Active Requests'
+                 :requests='requests')
+  p(v-else) Loading journal...
+</template>
+
+<script>
+'use strict'
+
+import { mapState } from 'vuex'
+
+import RequestList from '@/components/request/RequestList'
+
+import actions from '@/store/action-types'
+
+export default {
+  name: 'active-requests',
+  inject: ['progress'],
+  components: {
+    RequestList
+  },
+  data () {
+    return {
+      requests: [],
+      loaded: false
+    }
+  },
+  computed: {
+    ...mapState(['journal', 'isLoadingJournal'])
+  },
+  created () {
+    this.$on('requestUnsnoozed', this.ensureJournal)
+    this.$on('requestNowShown', this.ensureJournal)
+  },
+  methods: {
+    async ensureJournal () {
+      if (!Array.isArray(this.journal)) {
+        this.loaded = false
+        await this.$store.dispatch(actions.LOAD_JOURNAL, this.progress)
+      }
+      this.requests = this.journal
+        .sort((a, b) => a.showAfter - b.showAfter)
+      this.loaded = true
+    }
+  },
+  async mounted () {
+    await this.ensureJournal()
+  }
+}
+</script>

src/app/src/components/request/AnsweredRequests.vue

@@ -0,0 +1,53 @@
+<template lang="pug">
+md-content(role='main').mpj-main-content
+  page-title(title='Answered Requests'
+             hide-on-page=true)
+  template(v-if='loaded')
+    md-empty-state(v-if='requests.length === 0'
+                   md-icon='sentiment_dissatisfied'
+                   md-label='No Answered Requests'
+                   md-description='Your prayer journal has no answered requests; once you have marked one as “Answered”, it will appear here')
+    request-list(v-if='requests.length !== 0'
+                 title='Answered Requests'
+                 :requests='requests')
+  p(v-else) Loading answered requests...
+</template>
+
+<script>
+'use strict'
+
+import api from '@/api'
+
+import RequestList from '@/components/request/RequestList'
+
+export default {
+  name: 'answered-requests',
+  inject: [
+    'messages',
+    'progress'
+  ],
+  components: {
+    RequestList
+  },
+  data () {
+    return {
+      requests: [],
+      loaded: false
+    }
+  },
+  async mounted () {
+    this.progress.$emit('show', 'query')
+    try {
+      const reqs = await api.getAnsweredRequests()
+      this.requests = reqs.data
+      this.progress.$emit('done')
+    } catch (err) {
+      console.error(err)
+      this.messages.$emit('error', 'Error loading requests; check console for details')
+      this.progress.$emit('done')
+    } finally {
+      this.loaded = true
+    }
+  }
+}
+</script>

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

@@ -1,88 +1,173 @@
 <template lang="pug">
-b-modal(v-model='editVisible'
+md-content(role='main').mpj-narrow
-        header-bg-variant='mpj'
+  page-title(:title='title')
-        header-text-variant='light'
+  md-field
-        size='lg'
+    label(for='request_text') Prayer Request
-        title='Edit Prayer Request'
+    md-textarea(v-model='form.requestText'
-        @edit='openDialog()'
+                @blur='trimText()'
-        @shows='focusRequestText')
+                md-autogrow
-  b-form
+                autofocus).mpj-full-width
-    b-form-group(label='Prayer Request'
+  br
-                 label-for='request_text')
+  template(v-if='!isNew')
-      b-textarea#request_text(ref='toFocus'
+    label Also Mark As
-                              v-model='form.requestText'
+    br
-                              :rows='10'
+    md-radio(v-model='form.status'
-                              @blur='trimText()')
+             value='Updated') Updated
-    b-form-group(label='Also Mark As')
+    md-radio(v-model='form.status'
-      b-radio-group(v-model='form.status'
+             value='Prayed') Prayed
-                    buttons)
+    md-radio(v-model='form.status'
-        b-radio(value='Updated') Updated
+             value='Answered') Answered
-        b-radio(value='Prayed') Prayed
+    br
-        b-radio(value='Answered') Answered
+  label Recurrence
-  div.w-100.text-right(slot='modal-footer')
+  | &nbsp; &nbsp;
-    b-btn(variant='primary'
+  em.mpj-muted-text After prayer, request reappears...
-          @click='saveRequest()') Save
+  br
-    | &nbsp; &nbsp;
+  .md-layout
-    b-btn(variant='outline-secondary'
+    .md-layout-item.md-size-30
-          @click='closeDialog()') Cancel
+      md-radio(v-model='form.recur.typ'
+              value='Immediate') Immediately
+    .md-layout-item.md-size-20
+      md-radio(v-model='form.recur.typ'
+              value='other') Every...
+    .md-layout-item.md-size-10
+      md-field(md-inline)
+        label Count
+        md-input(v-model='form.recur.count'
+                type='number'
+                :disabled='!showRecurrence')
+    .md-layout-item.md-size-20
+      md-field
+        label Interval
+        md-select(v-model='form.recur.other'
+                  :disabled='!showRecurrence')
+          md-option(value='Hours') hours
+          md-option(value='Days') days
+          md-option(value='Weeks') weeks
+  .mpj-text-right
+    md-button(:disabled='!isValidRecurrence'
+              @click.stop='saveRequest()').md-primary.md-raised #[md-icon save] Save
+    md-button(@click.stop='goBack()').md-raised #[md-icon arrow_back] Cancel
 </template>
 
 <script>
 'use strict'
 
+import { mapState } from 'vuex'
+
 import actions from '@/store/action-types'
 
 export default {
   name: 'edit-request',
+  inject: [
+    'messages',
+    'progress'
+  ],
   props: {
-    toast: { required: true },
+    id: {
-    events: { required: true }
+      type: String,
+      required: true
+    }
   },
   data () {
     return {
-      editVisible: false,
+      title: 'Edit Prayer Request',
+      isNew: false,
       form: {
         requestId: '',
         requestText: '',
-        status: 'Updated'
+        status: 'Updated',
+        recur: {
+          typ: 'Immediate',
+          other: '',
+          count: ''
+        }
       }
     }
   },
-  created () {
+  computed: {
-    this.events.$on('edit', this.openDialog)
+    isValidRecurrence () {
+      if (this.form.recur.typ === 'Immediate') return true
+      const count = Number.parseInt(this.form.recur.count)
+      if (isNaN(count) || this.form.recur.other === '') return false
+      if (this.form.recur.other === 'Hours' && count > (365 * 24)) return false
+      if (this.form.recur.other === 'Days' && count > 365) return false
+      if (this.form.recur.other === 'Weeks' && count > 52) return false
+      return true
+    },
+    showRecurrence () {
+      return this.form.recur.typ !== 'Immediate'
+    },
+    ...mapState(['journal'])
   },
-  methods: {
+  async mounted () {
-    closeDialog () {
+    await this.ensureJournal()
+    if (this.id === 'new') {
+      this.title = 'Add Prayer Request'
+      this.isNew = true
       this.form.requestId = ''
       this.form.requestText = ''
+      this.form.status = 'Created'
+      this.form.recur.typ = 'Immediate'
+      this.form.recur.other = ''
+      this.form.recur.count = ''
+    } else {
+      this.title = 'Edit Prayer Request'
+      this.isNew = false
+      if (this.journal.length === 0) {
+        await this.$store.dispatch(actions.LOAD_JOURNAL, this.progress)
+      }
+      const req = this.journal.filter(r => r.requestId === this.id)[0]
+      this.form.requestId = this.id
+      this.form.requestText = req.text
       this.form.status = 'Updated'
-      this.editVisible = false
+      if (req.recurType === 'Immediate') {
-    },
+        this.form.recur.typ = 'Immediate'
-    focusRequestText (e) {
+        this.form.recur.other = ''
-      this.$refs.toFocus.focus()
+        this.form.recur.count = ''
-    },
+      } else {
-    openDialog (request) {
+        this.form.recur.typ = 'other'
-      this.form.requestId = request.requestId
+        this.form.recur.other = req.recurType
-      this.form.requestText = request.text
+        this.form.recur.count = req.recurCount
-      this.editVisible = true
+      }
-      this.focusRequestText(null)
+    }
+  },
+  methods: {
+    goBack () {
+      this.$router.go(-1)
     },
     trimText () {
       this.form.requestText = this.form.requestText.trim()
     },
-    async saveRequest () {
+    async ensureJournal () {
-      await this.$store.dispatch(actions.UPDATE_REQUEST, {
+      if (!Array.isArray(this.journal)) {
-        progress: this.$Progress,
+        await this.$store.dispatch(actions.LOAD_JOURNAL, 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()
+    },
+    async saveRequest () {
+      if (this.isNew) {
+        await this.$store.dispatch(actions.ADD_REQUEST, {
+          progress: this.progress,
+          requestText: this.form.requestText,
+          recurType: this.form.recur.typ === 'Immediate' ? 'Immediate' : this.form.recur.other,
+          recurCount: this.form.recur.typ === 'Immediate' ? 0 : Number.parseInt(this.form.recur.count)
+        })
+        this.messages.$emit('info', 'New prayer request added')
+      } else {
+        await this.$store.dispatch(actions.UPDATE_REQUEST, {
+          progress: this.progress,
+          requestId: this.form.requestId,
+          updateText: this.form.requestText,
+          status: this.form.status,
+          recurType: this.form.recur.typ === 'Immediate' ? 'Immediate' : this.form.recur.other,
+          recurCount: this.form.recur.typ === 'Immediate' ? 0 : Number.parseInt(this.form.recur.count)
+        })
+        if (this.form.status === 'Answered') {
+          this.messages.$emit('info', 'Request updated and removed from active journal')
+        } else {
+          this.messages.$emit('info', 'Request updated')
+        }
+      }
+      this.goBack()
     }
   }
 }

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

@@ -1,56 +1,93 @@
 <template lang="pug">
-span
+md-content(role='main').mpj-main-content
-  b-modal(v-model='historyVisible'
+  page-title(title='Full Prayer Request'
-          header-bg-variant='mpj'
+             hide-on-page=true)
-          header-text-variant='light'
+  md-card(v-if='request')
-          size='lg'
+    md-card-header
-          title='Prayer Request History'
+      .md-title Full Prayer Request
-          @shows='focusRequestText')
+      .md-subhead
-    b-list-group(v-if='null !== full'
+        span(v-if='isAnswered') Answered {{ formatDate(answered) }} (#[date-from-now(:value='answered')]) !{' &bull; '}
-                 flush)
+        | Prayed {{ prayedCount }} times &bull; Open {{ openDays }} days
-      full-request-history(v-for='item in full.history'
+    md-card-content.mpj-full-page-card
-                           :key='item.asOf'
+      p.mpj-request-text {{ lastText }}
-                           :history='item')
+      md-table
-    div.w-100.text-right(slot='modal-footer')
+        md-table-row
-      b-btn(variant='primary'
+          md-table-head Action
-            @click='closeDialog()') Close
+          md-table-head Update / Notes
+        md-table-row(v-for='item in log'
+                     :key='item.asOf')
+          md-table-cell.mpj-valign-top {{ item.status }} on #[span.mpj-text-nowrap {{ formatDate(item.asOf) }}]
+          md-table-cell(v-if='item.text').mpj-request-text.mpj-valign-top {{ item.text }}
+          md-table-cell(v-else) &nbsp;
+  p(v-else) Loading request...
 </template>
 
 <script>
 'use strict'
 
-import FullRequestHistory from './FullRequestHistory'
+import moment from 'moment'
 
 import api from '@/api'
 
+const asOfDesc = (a, b) => b.asOf - a.asOf
+
 export default {
   name: 'full-request',
-  components: {
+  inject: ['progress'],
-    FullRequestHistory
-  },
   props: {
-    events: { required: true }
+    id: {
+      type: String,
+      required: true
+    }
   },
   data () {
     return {
-      historyVisible: false,
+      request: null
-      full: null
     }
   },
-  created () {
+  computed: {
-    this.events.$on('full', this.openDialog)
+    answered () {
+      return this.request.history.find(hist => hist.status === 'Answered').asOf
+    },
+    isAnswered () {
+      return this.request.history.filter(hist => hist.status === 'Answered').length > 0
+    },
+    lastText () {
+      return this.request.history
+        .filter(hist => hist.text)
+        .sort(asOfDesc)[0].text
+    },
+    log () {
+      const allHistory = (this.request.notes || [])
+        .map(note => ({ asOf: note.asOf, text: note.notes, status: 'Notes' }))
+        .concat(this.request.history)
+        .sort(asOfDesc)
+      // Skip the first entry for answered requests; that info is already displayed
+      return this.isAnswered ? allHistory.slice(1) : allHistory
+    },
+    openDays () {
+      const asOf = this.isAnswered ? this.answered : Date.now()
+      return Math.floor(
+        (asOf - 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.$emit('show', 'indeterminate')
+    try {
+      const req = await api.getFullRequest(this.id)
+      this.request = req.data
+      this.progress.$emit('done')
+    } catch (e) {
+      console.log(e)
+      this.progress.$emit('done')
+    }
   },
   methods: {
-    closeDialog () {
+    formatDate (asOf) {
-      this.full = null
+      return moment(asOf).format('LL')
-      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()
     }
   }
 }

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

@@ -1,28 +0,0 @@
-<template lang="pug">
-b-list-group-item
-  | {{ history.status }}
-  |
-  small.text-muted(:title='actualDate') {{ asOf }}
-  div(v-if='history.text').mpj-request-text {{ history.text.fields[0] }}
-</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()
-    },
-    actualDate () {
-      return moment(this.history.asOf).format('LLLL')
-    }
-  }
-}
-</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,36 +1,28 @@
 <template lang="pug">
-b-modal(v-model='notesVisible'
+md-dialog(:md-active.sync='notesVisible').mpj-note-dialog
-        header-bg-variant='mpj'
+  md-dialog-title Add Notes to Prayer Request
-        header-text-variant='light'
+  md-content.mpj-dialog-content
-        size='lg'
+    md-field
-        title='Add Notes to Prayer Request'
+      label Notes
-        @edit='openDialog()'
+      md-textarea(v-model='form.notes'
-        @shows='focusNotes')
+                  md-autogrow
-  b-form
+                  @blur='trimText()')
-    b-form-group(label='Notes'
+  md-dialog-actions
-                 label-for='notes')
+    md-button(@click='saveNotes()').md-primary #[md-icon save] Save
-      b-textarea#notes(ref='toFocus'
+    md-button(@click='closeDialog()') #[md-icon undo] Cancel
-                       v-model='form.notes'
+  md-dialog-content(md-scrollbar='true').mpj-dialog-content
-                       :rows='10'
+    div(v-if='hasPriorNotes')
-                       @blur='trimText()')
+      p.mpj-text-center: strong Prior Notes for This Request
-  div(v-if='hasPriorNotes')
+      .mpj-note-list
-    p.text-center: strong Prior Notes for This Request
+        p(v-for='note in priorNotes'
-    b-list-group(flush)
+          :key='note.asOf')
-      b-list-group-item(v-for='note in priorNotes'
+          small.mpj-muted-text: date-from-now(:value='note.asOf')
-                        :key='note.asOf')
+          br
-        small.text-muted: date-from-now(:value='note.asOf')
+          span.mpj-request-text {{ note.notes }}
-        br
+    div(v-else-if='noPriorNotes').mpj-text-center.mpj-muted-text There are no prior notes for this request
-        div.mpj-request-text {{ note.notes }}
+    div(v-else).mpj-text-center
-  div(v-else-if='noPriorNotes').text-center.text-muted There are no prior notes for this request
+      hr
-  div(v-else).text-center
+      md-button(@click='loadNotes()') #[md-icon cloud_download] Load Prior Notes
-    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>
@@ -40,10 +32,11 @@ import api from '@/api'
 
 export default {
   name: 'notes-edit',
-  props: {
+  inject: [
-    toast: { required: true },
+    'journalEvents',
-    events: { required: true }
+    'messages',
-  },
+    'progress'
+  ],
   data () {
     return {
       notesVisible: false,
@@ -64,7 +57,7 @@ export default {
     }
   },
   created () {
-    this.events.$on('notes', this.openDialog)
+    this.journalEvents.$on('notes', this.openDialog)
   },
   methods: {
     closeDialog () {
@@ -74,19 +67,15 @@ export default {
       this.priorNotesLoaded = false
       this.notesVisible = false
     },
-    focusNotes (e) {
-      this.$refs.toFocus.focus()
-    },
     async loadNotes () {
-      this.$Progress.start()
+      this.progress.$emit('show', 'indeterminate')
       try {
         const notes = await api.getNotes(this.form.requestId)
-        this.priorNotes = notes.data
+        this.priorNotes = notes.data.sort((a, b) => b.asOf - a.asOf)
-        console.log(this.priorNotes)
+        this.progress.$emit('done')
-        this.$Progress.finish()
       } catch (e) {
         console.error(e)
-        this.$Progress.fail()
+        this.progress.$emit('done')
       } finally {
         this.priorNotesLoaded = true
       }
@@ -94,18 +83,17 @@ export default {
     openDialog (request) {
       this.form.requestId = request.requestId
       this.notesVisible = true
-      this.focusNotes(null)
     },
     async saveNotes () {
-      this.$Progress.start()
+      this.progress.$emit('show', 'indeterminate')
       try {
         await api.addNote(this.form.requestId, this.form.notes)
-        this.$Progress.finish()
+        this.progress.$emit('done')
-        this.toast.showToast('Added notes', { theme: 'success' })
+        this.messages.$emit('info', 'Added notes')
         this.closeDialog()
       } catch (e) {
         console.error(e)
-        this.$Progress.fail()
+        this.progress.$emit('done')
       }
     },
     trimText () {
@@ -114,3 +102,17 @@ export default {
   }
 }
 </script>
+
+<style lang="sass">
+.mpj-note-dialog
+  width: 40rem
+  padding-bottom: 1.5rem
+@media screen and (max-width: 40rem)
+  @media screen and (max-width: 20rem)
+    .mpj-note-dialog
+      width: 100%
+  .mpj-note-dialog
+    width: 20rem
+.mpj-note-list p
+  border-top: dotted 1px lightgray
+</style>

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

@@ -1,19 +1,27 @@
 <template lang="pug">
-b-col(v-if="!isSnoozed" md='6' lg='4')
+md-card(v-if='shouldDisplay'
-  .mpj-request-card
+        md-with-hover).mpj-request-card
-    b-card-header.text-center.py-1.
+  md-card-actions(md-alignment='space-between')
-      #[b-btn(@click='markPrayed()' variant='outline-primary' title='Pray' size='sm'): icon(name='check')]
+    md-button(@click='markPrayed()').md-icon-button.md-raised.md-primary
-      #[b-btn(@click.stop='showEdit()' variant='outline-secondary' title='Edit' size='sm'): icon(name='pencil')]
+      md-icon done
-      #[b-btn(@click.stop='showNotes()' variant='outline-secondary' title='Add Notes' size='sm'): icon(name='file-text-o')]
+      md-tooltip(md-direction='top'
-      #[b-btn(@click.stop='showFull()' variant='outline-secondary' title='View Full Request' size='sm'): icon(name='search')]
+                 md-delay=1000) Mark as Prayed
-      #[b-btn(@click.stop='snooze()' variant='outline-secondary' title='Snooze Request' size='sm'): icon(name='clock-o')]
+    span
-    b-card-body.p-0
+      md-button(@click.stop='showEdit()').md-icon-button.md-raised
-      p.card-text.mpj-request-text.mb-1.px-3.pt-3
+        md-icon edit
-        | {{ request.text }}
+        md-tooltip(md-direction='top'
-      p.card-text.p-0.pr-1.text-right: small.text-muted: em
+                   md-delay=1000) Edit Request
-        = '(last activity '
+      md-button(@click.stop='showNotes()').md-icon-button.md-raised
-        date-from-now(:value='request.asOf')
+        md-icon comment
-        | )
+        md-tooltip(md-direction='top'
+                   md-delay=1000) Add Notes
+      md-button(@click.stop='snooze()').md-icon-button.md-raised
+        md-icon schedule
+        md-tooltip(md-direction='top'
+                   md-delay=1000) Snooze Request
+  md-card-content
+    p.mpj-request-text {{ request.text }}
+    p.mpj-text-right: small.mpj-muted-text: em (last activity #[date-from-now(:value='request.asOf')])
 </template>
 
 <script>
@@ -23,46 +31,48 @@ import actions from '@/store/action-types'
 
 export default {
   name: 'request-card',
+  inject: [
+    'journalEvents',
+    'messages',
+    'progress'
+  ],
   props: {
-    request: { required: true },
+    request: { required: true }
-    toast: { required: true },
-    events: { required: true }
   },
   computed: {
-    isSnoozed () {
+    shouldDisplay () {
-      return Date.now() < this.request.snoozedUntil
+      const now = Date.now()
+      return Math.max(now, this.request.showAfter, this.request.snoozedUntil) === now
     }
   },
   methods: {
     async markPrayed () {
       await this.$store.dispatch(actions.UPDATE_REQUEST, {
-        progress: this.$Progress,
+        progress: this.progress,
         requestId: this.request.requestId,
         status: 'Prayed',
         updateText: ''
       })
-      this.toast.showToast('Request marked as prayed', { theme: 'success' })
+      this.messages.$emit('info', 'Request marked as prayed')
     },
     showEdit () {
-      this.events.$emit('edit', this.request)
+      this.$router.push({ name: 'EditRequest', params: { id: this.request.requestId } })
-    },
-    showFull () {
-      this.events.$emit('full', this.request.requestId)
     },
     showNotes () {
-      this.events.$emit('notes', this.request)
+      this.journalEvents.$emit('notes', this.request)
     },
     snooze () {
-      this.events.$emit('snooze', this.request.requestId)
+      this.journalEvents.$emit('snooze', this.request.requestId)
     }
   }
 }
 </script>
 
-<style>
+<style lang="sass">
-.mpj-request-card {
+.mpj-request-card
-  border: solid 1px darkgray;
+  width: 20rem
-  border-radius: 5px;
+  margin-bottom: 1rem
-  margin-bottom: 15px;
+@media screen and (max-width: 20rem)
-}
+  .mpj-request-card
+    width: 100%
 </style>

src/app/src/components/request/RequestList.vue

@@ -0,0 +1,40 @@
+<template lang="pug">
+md-table(md-card)
+  md-table-toolbar
+    h1.md-title {{ title }}
+  md-table-row
+    md-table-head Actions
+    md-table-head Request
+  request-list-item(v-for='req in requests'
+                    :key='req.requestId'
+                    :request='req')
+
+</template>
+
+<script>
+'use strict'
+
+import RequestListItem from '@/components/request/RequestListItem'
+
+export default {
+  name: 'request-list',
+  components: { RequestListItem },
+  props: {
+    title: {
+      type: String,
+      required: true
+    },
+    requests: {
+      type: Array,
+      required: true
+    }
+  },
+  data () {
+    return { }
+  },
+  created () {
+    this.$on('requestUnsnoozed', this.$parent.$emit('requestUnsnoozed'))
+    this.$on('requestNowShown', this.$parent.$emit('requestNowShown'))
+  }
+}
+</script>

src/app/src/components/request/RequestListItem.vue

@@ -0,0 +1,95 @@
+<template lang="pug">
+md-table-row
+  md-table-cell.mpj-action-cell.mpj-valign-top
+    md-button(@click='viewFull').md-icon-button.md-raised
+      md-icon description
+      md-tooltip(md-direction='top'
+                 md-delay=250) View Full Request
+    template(v-if='!isAnswered')
+      md-button(@click='editRequest').md-icon-button.md-raised
+        md-icon edit
+        md-tooltip(md-direction='top'
+                   md-delay=250) Edit Request
+    template(v-if='isSnoozed')
+      md-button(@click='cancelSnooze()').md-icon-button.md-raised
+        md-icon restore
+        md-tooltip(md-direction='top'
+                   md-delay=250) Cancel Snooze
+    template(v-if='isPending')
+      md-button(@click='showNow()').md-icon-button.md-raised
+        md-icon restore
+        md-tooltip(md-direction='top'
+                   md-delay=250) Show Now
+  md-table-cell.mpj-valign-top
+    p.mpj-request-text {{ request.text }}
+    br(v-if='isSnoozed || isPending || isAnswered')
+    small(v-if='isSnoozed').mpj-muted-text: em Snooze expires #[date-from-now(:value='request.snoozedUntil')]
+    small(v-if='isPending').mpj-muted-text: em Request appears next #[date-from-now(:value='request.showAfter')]
+    small(v-if='isAnswered').mpj-muted-text: em Answered #[date-from-now(:value='request.asOf')]
+</template>
+
+<script>
+'use strict'
+
+import actions from '@/store/action-types'
+
+export default {
+  name: 'request-list-item',
+  inject: [
+    'messages',
+    'progress'
+  ],
+  props: {
+    request: { required: true }
+  },
+  data () {
+    return {}
+  },
+  computed: {
+    answered () {
+      return this.request.history.find(hist => hist.status === 'Answered').asOf
+    },
+    isAnswered () {
+      return this.request.lastStatus === 'Answered'
+    },
+    isPending () {
+      return !this.isSnoozed && this.request.showAfter > Date.now()
+    },
+    isSnoozed () {
+      return this.request.snoozedUntil > Date.now()
+    }
+  },
+  methods: {
+    async cancelSnooze () {
+      await this.$store.dispatch(actions.SNOOZE_REQUEST, {
+        progress: this.progress,
+        requestId: this.request.requestId,
+        until: 0
+      })
+      this.messages.$emit('info', 'Request un-snoozed')
+      this.$parent.$emit('requestUnsnoozed')
+    },
+    editRequest () {
+      this.$router.push({ name: 'EditRequest', params: { id: this.request.requestId } })
+    },
+    async showNow () {
+      await this.$store.dispatch(actions.SHOW_REQUEST_NOW, {
+        progress: this.progress,
+        requestId: this.request.requestId,
+        showAfter: 0
+      })
+      this.messages.$emit('info', 'Recurrence skipped; request now shows in journal')
+      this.$parent.$emit('requestNowShown')
+    },
+    viewFull () {
+      this.$router.push({ name: 'FullRequest', params: { id: this.request.requestId } })
+    }
+  }
+}
+</script>
+
+<style lang="sass">
+.mpj-action-cell
+  width: 1%
+  white-space: nowrap
+</style>

src/app/src/components/request/SnoozeRequest.vue

@@ -1,23 +1,15 @@
 <template lang="pug">
-b-modal(v-model='snoozeVisible'
+md-dialog(:md-active.sync='snoozeVisible').mpj-skinny
-        header-bg-variant='mpj'
+  md-dialog-title Snooze Prayer Request
-        header-text-variant='light'
+  md-content.mpj-dialog-content
-        size='lg'
+    span.mpj-text-muted Until
-        title='Snooze Prayer Request'
+    md-datepicker(v-model='form.snoozedUntil'
-        @edit='openDialog()')
+                  :md-disabled-dates='datesInPast'
-  b-form
+                  md-immediately)
-    b-form-group(label='Until'
+  md-dialog-actions
-                 label-for='until')
+    md-button(:disabled='!isValid'
-      b-input#until(type='date'
+              @click='snoozeRequest()').md-primary #[md-icon snooze] Snooze
-                    v-model='form.snoozedUntil'
+    md-button(@click='closeDialog()') #[md-icon undo] Cancel
-                    autofocus)
-  div.w-100.text-right(slot='modal-footer')
-    b-btn(variant='primary'
-          :disabled='!isValid'
-          @click='snoozeRequest()') Snooze
-    | &nbsp; &nbsp;
-    b-btn(variant='outline-secondary'
-          @click='closeDialog()') Cancel
 </template>
 
 <script>
@@ -27,13 +19,18 @@ import actions from '@/store/action-types'
 
 export default {
   name: 'snooze-request',
+  inject: [
+    'journalEvents',
+    'messages',
+    'progress'
+  ],
   props: {
-    toast: { required: true },
     events: { required: true }
   },
   data () {
     return {
       snoozeVisible: false,
+      datesInPast: date => date < new Date(),
       form: {
         requestId: '',
         snoozedUntil: ''
@@ -41,7 +38,7 @@ export default {
     }
   },
   created () {
-    this.events.$on('snooze', this.openDialog)
+    this.journalEvents.$on('snooze', this.openDialog)
   },
   computed: {
     isValid () {
@@ -60,11 +57,11 @@ export default {
     },
     async snoozeRequest () {
       await this.$store.dispatch(actions.SNOOZE_REQUEST, {
-        progress: this.$Progress,
+        progress: this.progress,
         requestId: this.form.requestId,
         until: Date.parse(this.form.snoozedUntil)
       })
-      this.toast.showToast(`Request snoozed until ${this.form.snoozedUntil}`, { theme: 'success' })
+      this.messages.$emit('info', `Request snoozed until ${this.form.snoozedUntil}`)
       this.closeDialog()
     }
   }

src/app/src/components/request/SnoozedRequests.vue

@@ -0,0 +1,60 @@
+<template lang="pug">
+article.mpj-main-content(role='main')
+  page-title(title='Snoozed Requests'
+             hide-on-page=true)
+  template(v-if='loaded')
+    md-empty-state(v-if='requests.length === 0'
+                   md-icon='sentiment_dissatisfied'
+                   md-label='No Snoozed Requests'
+                   md-description='Your prayer journal has no snoozed requests')
+      md-button(to='/journal').md-primary.md-raised Return to your journal
+    request-list(v-if='requests.length !== 0'
+                 title='Snoozed Requests'
+                 :requests='requests')
+  p(v-else) Loading journal...
+</template>
+
+<script>
+'use strict'
+
+import { mapState } from 'vuex'
+
+import actions from '@/store/action-types'
+
+import RequestList from '@/components/request/RequestList'
+
+export default {
+  name: 'snoozed-requests',
+  inject: ['progress'],
+  components: {
+    RequestList
+  },
+  data () {
+    return {
+      requests: [],
+      loaded: false
+    }
+  },
+  computed: {
+    ...mapState(['journal', 'isLoadingJournal'])
+  },
+  created () {
+    this.$on('requestUnsnoozed', this.ensureJournal)
+  },
+  methods: {
+    async ensureJournal () {
+      if (!Array.isArray(this.journal)) {
+        this.loaded = false
+        await this.$store.dispatch(actions.LOAD_JOURNAL, this.progress)
+      }
+      this.requests = this.journal
+        .filter(req => req.snoozedUntil > Date.now())
+        .sort((a, b) => a.snoozedUntil - b.snoozedUntil)
+      this.loaded = true
+    }
+  },
+  async mounted () {
+    await this.ensureJournal()
+  }
+}
+</script>

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

@@ -1,5 +1,5 @@
 <template lang="pug">
-article
+article.mpj-main-content(role='main')
   pageTitle(title='Logging On')
   p Logging you on...
 </template>
@@ -7,14 +7,17 @@ article
 <script>
 'use strict'
 
-import AuthService from '@/auth/AuthService'
-
 export default {
   name: 'log-on',
-  created () {
+  inject: ['progress'],
-    this.$Progress.start()
+  async created () {
-    new AuthService().handleAuthentication(this.$store, this.$router)
+    this.progress.$emit('show', 'indeterminate')
-    // Auth service redirects to dashboard, which restarts the progress bar
+    await this.$auth.handleAuthentication(this.$store)
+  },
+  methods: {
+    handleLoginEvent (data) {
+      this.$router.push(data.state.target || '/journal')
+    }
   }
 }
 </script>

src/app/src/main.js

@@ -1,54 +1,64 @@
-// The Vue build version to load with the `import` command
+/* eslint-disable */
-// (runtime-only or standalone) has been set in webpack.base.conf with an alias.
+
+// Vue packages and components
 import Vue from 'vue'
-import BootstrapVue from 'bootstrap-vue'
+import { MdApp,
-import Icon from 'vue-awesome/components/Icon'
+         MdButton,
-import VueProgressBar from 'vue-progressbar'
+         MdCard,
-import VueToast from 'vue-toast'
+         MdContent,
+         MdDatepicker,
+         MdDialog,
+         MdEmptyState,
+         MdField,
+         MdIcon,
+         MdLayout,
+         MdProgress,
+         MdRadio,
+         MdSnackbar,
+         MdTable,
+         MdTabs,
+         MdToolbar,
+         MdTooltip } from 'vue-material/dist/components'
 
-import 'bootstrap-vue/dist/bootstrap-vue.css'
+// myPrayerJournal components
-import 'bootstrap/dist/css/bootstrap.css'
+import App         from './App'
-import 'vue-toast/dist/vue-toast.min.css'
+import router      from './router'
-
+import store       from './store'
-// Only import the icons we need; the whole set is ~500K!
-import 'vue-awesome/icons/check'
-import 'vue-awesome/icons/clock-o'
-import 'vue-awesome/icons/file-text-o'
-import 'vue-awesome/icons/pencil'
-import 'vue-awesome/icons/plus'
-import 'vue-awesome/icons/search'
-import 'vue-awesome/icons/times'
-
-import App from './App'
-import router from './router'
-import store from './store'
 import DateFromNow from './components/common/DateFromNow'
-import PageTitle from './components/common/PageTitle'
+import PageTitle   from './components/common/PageTitle'
+import AuthPlugin  from './plugins/auth'
+
+/* eslint-enable */
+
+// Styles
+import 'vue-material/dist/vue-material.min.css'
+import 'vue-material/dist/theme/default.css'
 
 Vue.config.productionTip = false
 
-Vue.use(BootstrapVue)
+Vue.use(MdApp)
-Vue.use(VueProgressBar, {
+Vue.use(MdButton)
-  color: 'yellow',
+Vue.use(MdCard)
-  failedColor: 'red',
+Vue.use(MdContent)
-  height: '5px',
+Vue.use(MdDatepicker)
-  transition: {
+Vue.use(MdDialog)
-    speed: '0.2s',
+Vue.use(MdEmptyState)
-    opacity: '0.6s',
+Vue.use(MdField)
-    termination: 1000
+Vue.use(MdIcon)
-  }
+Vue.use(MdLayout)
-})
+Vue.use(MdProgress)
-
+Vue.use(MdRadio)
-Vue.component('icon', Icon)
+Vue.use(MdSnackbar)
+Vue.use(MdTable)
+Vue.use(MdTabs)
+Vue.use(MdToolbar)
+Vue.use(MdTooltip)
+Vue.use(AuthPlugin)
 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/>',
+  render: h => h(App)
-  components: { App }
+}).$mount('#app')
-})

src/app/src/plugins/auth.js

@@ -0,0 +1,22 @@
+'use strict'
+
+import authService from '../auth/AuthService'
+
+export default {
+  install (Vue) {
+    Vue.prototype.$auth = authService
+
+    Vue.mixin({
+      created () {
+        if (this.handleLoginEvent) {
+          authService.addListener('loginEvent', this.handleLoginEvent)
+        }
+      },
+      destroyed () {
+        if (this.handleLoginEvent) {
+          authService.removeListener('loginEvent', this.handleLoginEvent)
+        }
+      }
+    })
+  }
+}

src/app/src/router.js

@@ -0,0 +1,83 @@
+'use strict'
+
+/* eslint-disable */
+import Vue    from 'vue'
+import Router from 'vue-router'
+
+import auth from './auth/AuthService'
+import Home from '@/components/Home'
+/* eslint-enable */
+
+Vue.use(Router)
+
+export default new Router({
+  mode: 'history',
+  base: process.env.BASE_URL,
+  scrollBehavior (to, from, savedPosition) {
+    if (savedPosition) {
+      return savedPosition
+    } else {
+      return { x: 0, y: 0 }
+    }
+  },
+  beforeEach (to, from, next) {
+    if (to.path === '/' || to.path === '/user/log-on' || auth.isAuthenticated()) {
+      return next()
+    }
+    auth.login({ target: to.path })
+  },
+  routes: [
+    {
+      path: '/',
+      name: 'Home',
+      component: Home
+    },
+    {
+      path: '/journal',
+      name: 'Journal',
+      component: () => import('@/components/Journal')
+    },
+    {
+      path: '/legal/privacy-policy',
+      name: 'PrivacyPolicy',
+      component: () => import('@/components/legal/PrivacyPolicy')
+    },
+    {
+      path: '/legal/terms-of-service',
+      name: 'TermsOfService',
+      component: () => import('@/components/legal/TermsOfService')
+    },
+    {
+      path: '/request/:id/edit',
+      name: 'EditRequest',
+      component: () => import('@/components/request/EditRequest'),
+      props: true
+    },
+    {
+      path: '/request/:id/full',
+      name: 'FullRequest',
+      component: () => import('@/components/request/FullRequest'),
+      props: true
+    },
+    {
+      path: '/requests/active',
+      name: 'ActiveRequests',
+      component: () => import('@/components/request/ActiveRequests')
+    },
+    {
+      path: '/requests/answered',
+      name: 'AnsweredRequests',
+      component: () => import('@/components/request/AnsweredRequests')
+    },
+    {
+      path: '/requests/snoozed',
+      name: 'SnoozedRequests',
+      component: () => import('@/components/request/SnoozedRequests')
+    },
+    {
+      path: '/user/log-on',
+      name: 'LogOn',
+      component: () => import('@/components/user/LogOn')
+    }
+  ]
+})

src/app/src/router/index.js

@@ -1,60 +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'
-import PrivacyPolicy from '@/components/legal/PrivacyPolicy'
-import Snoozed from '@/components/Snoozed'
-import TermsOfService from '@/components/legal/TermsOfService'
-
-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: '/legal/privacy-policy',
-      name: 'PrivacyPolicy',
-      component: PrivacyPolicy
-    },
-    {
-      path: '/legal/terms-of-service',
-      name: 'TermsOfService',
-      component: TermsOfService
-    },
-    {
-      path: '/snoozed',
-      name: 'Snoozed',
-      component: Snoozed
-    },
-    {
-      path: '/user/log-on',
-      name: 'LogOn',
-      component: LogOn
-    }
-  ]
-})

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

@@ -3,10 +3,14 @@
 export default {
   /** Action to add a prayer request (pass request text) */
   ADD_REQUEST: 'add-request',
+  /** Action to check if a user is authenticated, refreshing the session first if it exists */
+  CHECK_AUTHENTICATION: 'check-authentication',
   /** Action to load the user's prayer journal */
   LOAD_JOURNAL: 'load-journal',
   /** Action to update a request */
   UPDATE_REQUEST: 'update-request',
+  /** Action to skip the remaining recurrence period */
+  SHOW_REQUEST_NOW: 'show-request-now',
   /** Action to snooze a request */
   SNOOZE_REQUEST: 'snooze-request'
 }

src/app/src/store/index.js

@@ -1,46 +1,71 @@
-import Vue from 'vue'
+'use strict'
+
+/* eslint-disable no-multi-spaces */
+import Vue  from 'vue'
 import Vuex from 'vuex'
 
-import api from '@/api'
+import api  from '@/api'
-import AuthService from '@/auth/AuthService'
+import auth from '@/auth/AuthService'
 
 import mutations from './mutation-types'
-import actions from './action-types'
+import actions   from './action-types'
+/* eslint-enable no-multi-spaces */
 
 Vue.use(Vuex)
 
-this.auth0 = new AuthService()
+/* eslint-disable no-console */
-
 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.error(error.response.data)
-    console.log(error.response.status)
+    console.error(error.response.status)
-    console.log(error.response.headers)
+    console.error(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)
+    console.error(error.request)
   } else {
     // Something happened in setting up the request that triggered an Error
-    console.log('Error', error.message)
+    console.error('Error', error.message)
   }
-  console.log(error.config)
+  console.error(`config: ${error.config}`)
 }
 
+/**
+ * Set the "Bearer" authorization header with the current access token
+ */
+const setBearer = async function () {
+  try {
+    await auth.getAccessToken()
+    api.setBearer(auth.session.id.token)
+  } catch (err) {
+    if (err === 'Not logged in') {
+      console.warn('API request attempted when user was not logged in')
+    } else {
+      console.error(err)
+    }
+  }
+}
+/* eslint-enable no-console */
+
+/**
+ * Get the sort value for a prayer request
+ * @param x The prayer request
+ */
+const sortValue = x => x.showAfter === 0 ? x.asOf : x.showAfter
+
+/**
+ * Sort journal requests either by asOf or showAfter
+ */
+const journalSort = (a, b) => sortValue(a) - sortValue(b)
+
 export default new Vuex.Store({
   state: {
-    user: JSON.parse(localStorage.getItem('user_profile') || '{}'),
+    user: auth.session.profile,
-    isAuthenticated: (() => {
+    isAuthenticated: auth.isAuthenticated(),
-      this.auth0.scheduleRenewal()
+    journal: [],
-      if (this.auth0.isAuthenticated()) {
-        api.setBearer(localStorage.getItem('id_token'))
-      }
-      return this.auth0.isAuthenticated()
-    })(),
-    journal: {},
     isLoadingJournal: false
   },
   mutations: {
@@ -48,7 +73,7 @@ export default new Vuex.Store({
       state.isLoadingJournal = flag
     },
     [mutations.LOADED_JOURNAL] (state, journal) {
-      state.journal = journal
+      state.journal = journal.sort(journalSort)
     },
     [mutations.REQUEST_ADDED] (state, newRequest) {
       state.journal.push(newRequest)
@@ -58,68 +83,101 @@ export default new Vuex.Store({
       if (request.lastStatus !== 'Answered') jrnl.push(request)
       state.journal = jrnl
     },
+    [mutations.SET_AUTHENTICATION] (state, value) {
+      state.isAuthenticated = value
+    },
     [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 }) {
+    async [actions.ADD_REQUEST] ({ commit }, { progress, requestText, recurType, recurCount }) {
-      progress.start()
+      progress.$emit('show', 'indeterminate')
       try {
-        const newRequest = await api.addRequest(requestText)
+        await setBearer()
+        const newRequest = await api.addRequest(requestText, recurType, recurCount)
         commit(mutations.REQUEST_ADDED, newRequest.data)
-        progress.finish()
+        progress.$emit('done')
       } catch (err) {
         logError(err)
-        progress.fail()
+        progress.$emit('done')
+      }
+    },
+    async [actions.CHECK_AUTHENTICATION] ({ commit }) {
+      try {
+        await auth.getAccessToken()
+        commit(mutations.SET_AUTHENTICATION, auth.isAuthenticated())
+      } catch (_) {
+        commit(mutations.SET_AUTHENTICATION, false)
       }
     },
     async [actions.LOAD_JOURNAL] ({ commit }, progress) {
-      commit(mutations.LOADED_JOURNAL, {})
+      commit(mutations.LOADED_JOURNAL, [])
-      progress.start()
+      progress.$emit('show', 'query')
       commit(mutations.LOADING_JOURNAL, true)
-      api.setBearer(localStorage.getItem('id_token'))
+      await setBearer()
       try {
         const jrnl = await api.journal()
         commit(mutations.LOADED_JOURNAL, jrnl.data)
-        progress.finish()
+        progress.$emit('done')
       } catch (err) {
         logError(err)
-        progress.fail()
+        progress.$emit('done')
       } finally {
         commit(mutations.LOADING_JOURNAL, false)
       }
     },
-    async [actions.UPDATE_REQUEST] ({ commit }, { progress, requestId, status, updateText }) {
+    async [actions.UPDATE_REQUEST] ({ commit, state }, { progress, requestId, status, updateText, recurType, recurCount }) {
-      progress.start()
+      progress.$emit('show', 'indeterminate')
       try {
-        await api.updateRequest({ requestId, status, updateText })
+        await setBearer()
+        let oldReq = (state.journal.filter(req => req.requestId === requestId) || [])[0] || {}
+        if (!(status === 'Prayed' && updateText === '')) {
+          if (status !== 'Answered' && (oldReq.recurType !== recurType || oldReq.recurCount !== recurCount)) {
+            await api.updateRecurrence(requestId, recurType, recurCount)
+          }
+        }
+        if (status !== 'Updated' || oldReq.text !== updateText) {
+          await api.updateRequest(requestId, status, oldReq.text !== updateText ? updateText : '')
+        }
         const request = await api.getRequest(requestId)
         commit(mutations.REQUEST_UPDATED, request.data)
-        progress.finish()
+        progress.$emit('done')
       } catch (err) {
         logError(err)
-        progress.fail()
+        progress.$emit('done')
+      }
+    },
+    async [actions.SHOW_REQUEST_NOW] ({ commit }, { progress, requestId, showAfter }) {
+      progress.$emit('show', 'indeterminate')
+      try {
+        await setBearer()
+        await api.showRequest(requestId, showAfter)
+        const request = await api.getRequest(requestId)
+        commit(mutations.REQUEST_UPDATED, request.data)
+        progress.$emit('done')
+      } catch (err) {
+        logError(err)
+        progress.$emit('done')
       }
     },
     async [actions.SNOOZE_REQUEST] ({ commit }, { progress, requestId, until }) {
-      progress.start()
+      progress.$emit('show', 'indeterminate')
       try {
+        await setBearer()
         await api.snoozeRequest(requestId, until)
         const request = await api.getRequest(requestId)
         commit(mutations.REQUEST_UPDATED, request.data)
-        progress.finish()
+        progress.$emit('done')
       } catch (err) {
         logError(err)
-        progress.fail()
+        progress.$emit('done')
       }
     }
   },

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

@@ -9,6 +9,8 @@ export default {
   REQUEST_ADDED: 'request-added',
   /** Mutation to replace a prayer request at the top of the current journal */
   REQUEST_UPDATED: 'request-updated',
+  /** Mutation for setting the authentication state */
+  SET_AUTHENTICATION: 'set-authentication',
   /** Mutation for logging a user off */
   USER_LOGGED_OFF: 'user-logged-off',
   /** Mutation for logging a user on (pass user) */

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' }
-      ]
-    }
-  })
-}

src/app/vue.config.js

@@ -0,0 +1,16 @@
+const webpack = require('webpack')
+// const BundleAnalyzerPlugin = require('webpack-bundle-analyzer').BundleAnalyzerPlugin;
+module.exports = {
+  outputDir: '../MyPrayerJournal.Api/wwwroot',
+  configureWebpack: {
+    plugins: [
+      // new BundleAnalyzerPlugin(),
+      new webpack.IgnorePlugin(/^\.\/locale$/, /moment$/)
+    ],
+    optimization: {
+      splitChunks: {
+        chunks: 'all'
+      }
+    }
+  }
+}

src/sql/16-recurrence.sql

@@ -0,0 +1,31 @@
+ALTER TABLE mpj.request
+  ADD COLUMN "showAfter" BIGINT NOT NULL DEFAULT 0;
+ALTER TABLE mpj.request
+  ADD COLUMN "recurType" VARCHAR(10) NOT NULL DEFAULT 'immediate';
+ALTER TABLE mpj.request
+  ADD COLUMN "recurCount" SMALLINT NOT NULL DEFAULT 0;
+CREATE OR REPLACE 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",
+    request."snoozedUntil",
+    request."showAfter",
+    request."recurType",
+    request."recurCount"
+  FROM mpj.request;