Merge branch 'master' of https://github.com/bit-badger/myPrayerJournal

Also deleted a file I missed

.gitignore

@@ -254,7 +254,8 @@ paket-files/
 
 # Compiled files / application
 src/api/build
-src/api/public/index.html
-src/api/public/static
-src/api/appsettings.json
-/build
+src/api/MyPrayerJournal.Api/wwwroot/index.html
+src/api/MyPrayerJournal.Api/wwwroot/static
+src/api/MyPrayerJournal.Api/appsettings.development.json
+/build
+src/*.exe

README.md

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

docs/index.md

@@ -4,7 +4,7 @@
 
 Journaling has a long history; it helps people remember what happened, and the act of writing helps people think about what happened and process it. A prayer journal is not a new concept; it helps you keep track of the requests for which you've prayed, you can use it to pray over things repeatedly, and you can write the result when the answer comes _(or it was "no")_.
 
-myPrayerJournal was borne of out of a personal desire I (Daniel) had to have something that would help me with my prayer life. When it's time to pray, it's not really time to use an app, so the design goal here is to keep it simple and unobtrusive. It will also help eliminate some of the downsides to a paper prayer journal, like not remembering whether you've prayed for a request, or running out of room to write another update on one.
+myPrayerJournal was borne of out of a personal desire [Daniel](https://github.com/danieljsummers) had to have something that would help him with his prayer life. When it's time to pray, it's not really time to use an app, so the design goal here is to keep it simple and unobtrusive. It will also help eliminate some of the downsides to a paper prayer journal, like not remembering whether you've prayed for a request, or running out of room to write another update on one.
 
 ## Finding the Site
 
@@ -38,12 +38,16 @@ The third button for each request has an icon that looks like a piece of paper w
 
 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.
+
 ## Answered Requests
 
 Next to "Journal" on the top navigation is the word "Answered." This page lists all answered requests, from most recent to least recent, along with the text of the request at the time it was marked as answered. It will also show you when it was marked answered. The button at the bottom of each request, with the magnifying glass and the words "Show Full Request", link to a page that shows that request's complete history and notes, along with a few statistics about that request. The history and notes are listed from most recent to least recent; if you want to read it chronologically, just press the "End" key on your keyboard and read it from the bottom up.
 
 ## Final Notes
 
-- myPrayerJournal is currently in public beta. If you encounter errors, please [file an issue on GitHub](https://github.com/danieljsummers/myPrayerJournal/issues) with as much detail as possible. You can also browse the list of issues to see what has been done and what is still left to do.
+- 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.
 - 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/api/MyPrayerJournal.Api/Data.fs

@@ -0,0 +1,283 @@
+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

@@ -0,0 +1,261 @@
+/// 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

@@ -0,0 +1,30 @@
+<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

@@ -0,0 +1,121 @@
+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.Api/Properties/launchSettings.json

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

src/api/MyPrayerJournal.Api/appsettings.json

@@ -0,0 +1,9 @@
+{
+  "Kestrel": {
+    "EndPoints": {
+      "Http": {
+        "Url": "http://localhost:3000"
+      }
+    }
+  }
+}

src/api/MyPrayerJournal.sln

@@ -0,0 +1,25 @@
+
+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/api/app.js

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

src/api/json.mjs

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

src/api/package.json

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

src/api/src/db/ddl.js

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

src/api/src/db/index.js

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

src/api/src/db/request.js

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

src/api/src/index.js

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

src/api/src/routes/index.js

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

src/api/src/routes/journal.js

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

src/api/src/routes/request.js

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

src/app/config/index.js

@@ -4,8 +4,8 @@ var path = require('path')
 module.exports = {
   build: {
     env: require('./prod.env'),
-    index: path.resolve(__dirname, '../../api/public/index.html'),
-    assetsRoot: path.resolve(__dirname, '../../api/public'),
+    index: path.resolve(__dirname, '../../api/MyPrayerJournal.Api/wwwroot/index.html'),
+    assetsRoot: path.resolve(__dirname, '../../api/MyPrayerJournal.Api/wwwroot'),
     assetsSubDirectory: 'static',
     assetsPublicPath: '/',
     productionSourceMap: true,

src/app/package.json

@@ -1,6 +1,6 @@
 {
   "name": "my-prayer-journal",
-  "version": "0.9.3",
+  "version": "0.9.7",
   "description": "myPrayerJournal - Front End",
   "author": "Daniel J. Summers <daniel@bitbadger.solutions>",
   "private": true,
@@ -11,7 +11,9 @@
     "unit": "cross-env BABEL_ENV=test karma start test/unit/karma.conf.js --single-run",
     "e2e": "node test/e2e/runner.js",
     "test": "npm run unit && npm run e2e",
-    "lint": "eslint --ext .js,.vue src test/unit/specs test/e2e/specs"
+    "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",

src/app/src/App.vue

@@ -12,7 +12,7 @@
       em: small.
         #[router-link(:to="{ name: 'PrivacyPolicy' }") Privacy Policy] •
         #[router-link(:to="{ name: 'TermsOfService' }") Terms of Service] •
-        #[a(href='https://github.com/danieljsummers/myprayerjournal') Developed] and hosted by
+        #[a(href='https://github.com/bit-badger/myprayerjournal') Developed] and hosted by
         #[a(href='https://bitbadger.solutions') Bit Badger Solutions]
 </template>
 

src/app/src/api/index.js

@@ -31,12 +31,12 @@ export default {
    * Add a new prayer request
    * @param {string} requestText The text of the request to be added
    */
-  addRequest: requestText => http.post('request/', { requestText }),
+  addRequest: requestText => http.post('request', { requestText }),
 
   /**
    * Get all answered requests, along with the text they had when it was answered
    */
-  getAnsweredRequests: () => http.get('request/answered'),
+  getAnsweredRequests: () => http.get('requests/answered'),
 
   /**
    * Get a prayer request (full; includes all history)
@@ -64,7 +64,14 @@ export default {
   /**
    * Get all prayer requests and their most recent updates
    */
-  journal: () => http.get('journal/'),
+  journal: () => http.get('journal'),
+
+  /**
+   * Snooze a request until the given time
+   * @param requestId {string} The ID of the prayer request to be snoozed
+   * @param until {number} The ticks until which the request should be snoozed
+   */
+  snoozeRequest: (requestId, until) => http.post(`request/${requestId}/snooze`, { until }),
 
   /**
    * Update a prayer request

src/app/src/components/Answered.vue

@@ -3,6 +3,8 @@ 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 “Answered”, it will appear here
     p.mpj-request-text(v-for='req in requests' :key='req.requestId')
       | {{ req.text }}
       br

src/app/src/components/AnsweredDetail.vue

@@ -10,6 +10,7 @@ article
     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>
@@ -44,12 +45,12 @@ export default {
     },
     lastText () {
       return this.request.history
-        .filter(hist => hist.text > '')
-        .sort(asOfDesc)[0].text
+        .filter(hist => hist.text)
+        .sort(asOfDesc)[0].text.fields[0]
     },
     log () {
-      return this.request.notes
-        .map(note => ({ asOf: note.asOf, text: note.notes, status: 'Notes' }))
+      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)

src/app/src/components/Journal.vue

@@ -11,12 +11,15 @@ article
                    :request='request'
                    :events='eventBus'
                    :toast='toast')
-    p.text-center(v-if='journal.length === 0'): em No requests found; click the "Add a New Request" button to add one
+    p.text-center(v-if='journal.length === 0'): em.
+      No requests found; click the “Add a New Request” button to add one
     edit-request(:events='eventBus'
                  :toast='toast')
     notes-edit(:events='eventBus'
                :toast='toast')
     full-request(:events='eventBus')
+    snooze-request(:events='eventBus'
+                   :toast='toast')
 </template>
 
 <script>
@@ -24,13 +27,13 @@ article
 
 import Vue from 'vue'
 import { mapState } from 'vuex'
-import chunk from 'lodash/chunk'
 
 import EditRequest from './request/EditRequest'
 import FullRequest from './request/FullRequest'
 import NewRequest from './request/NewRequest'
 import NotesEdit from './request/NotesEdit'
 import RequestCard from './request/RequestCard'
+import SnoozeRequest from './request/SnoozeRequest'
 
 import actions from '@/store/action-types'
 
@@ -41,7 +44,8 @@ export default {
     FullRequest,
     NewRequest,
     NotesEdit,
-    RequestCard
+    RequestCard,
+    SnoozeRequest
   },
   data () {
     return {
@@ -50,10 +54,7 @@ export default {
   },
   computed: {
     title () {
-      return `${this.user.given_name}'s Prayer Journal`
-    },
-    journalCardRows () {
-      return chunk(this.journal, 3)
+      return `${this.user.given_name}&rsquo;s Prayer Journal`
     },
     toast () {
       return this.$parent.$refs.toast

src/app/src/components/Navigation.vue

@@ -12,11 +12,13 @@ b-navbar(toggleable='sm'
     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://danieljsummers.github.io/myPrayerJournal/'
+      b-nav-item(href='https://bit-badger.github.io/myPrayerJournal/'
                  target='_blank'
                  @click.stop='') Docs
 </template>
@@ -35,7 +37,12 @@ export default {
     }
   },
   computed: {
-    ...mapState([ 'isAuthenticated' ])
+    hasSnoozed () {
+      return this.isAuthenticated &&
+        Array.isArray(this.journal) &&
+        this.journal.filter(req => req.snoozedUntil > Date.now()).length > 0
+    },
+    ...mapState([ 'journal', 'isAuthenticated' ])
   },
   methods: {
     logOn () {

src/app/src/components/Snoozed.vue

@@ -0,0 +1,76 @@
+<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/DateFromNow.vue

@@ -20,13 +20,16 @@ export default {
     }
   },
   data () {
-    const dt = moment(this.value)
     return {
-      fromNow: dt.fromNow(),
-      actual: dt.format('LLLL'),
+      fromNow: moment(this.value).fromNow(),
       intervalId: null
     }
   },
+  computed: {
+    actual () {
+      return moment(this.value).format('LLLL')
+    }
+  },
   mounted () {
     this.intervalId = setInterval(this.updateFromNow, this.interval)
     this.$watch('value', this.updateFromNow)

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

@@ -18,11 +18,11 @@ export default {
   },
   watch: {
     title () {
-      document.title = `${this.title} « myPrayerJournal`
+      document.title = `${this.title.replace('’', "'")} « myPrayerJournal`
     }
   },
   created () {
-    document.title = `${this.title} « myPrayerJournal`
+    document.title = `${this.title.replace('’', "'")} « myPrayerJournal`
   }
 }
 </script>

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

@@ -2,8 +2,8 @@
 b-list-group-item
   | {{ history.status }}
   |
-  small.text-muted {{ asOf }}
-  div(v-if='hasText').mpj-request-text {{ history.text }}
+  small.text-muted(:title='actualDate') {{ asOf }}
+  div(v-if='history.text').mpj-request-text {{ history.text.fields[0] }}
 </template>
 
 <script>
@@ -20,8 +20,8 @@ export default {
     asOf () {
       return moment(this.history.asOf).fromNow()
     },
-    hasText () {
-      return this.history.text.length > 0
+    actualDate () {
+      return moment(this.history.asOf).format('LLLL')
     }
   }
 }

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

@@ -1,11 +1,12 @@
 <template lang="pug">
-b-col(md='6' lg='4')
+b-col(v-if="!isSnoozed" md='6' lg='4')
   .mpj-request-card
     b-card-header.text-center.py-1.
       #[b-btn(@click='markPrayed()' variant='outline-primary' title='Pray' size='sm'): icon(name='check')]
       #[b-btn(@click.stop='showEdit()' variant='outline-secondary' title='Edit' size='sm'): icon(name='pencil')]
       #[b-btn(@click.stop='showNotes()' variant='outline-secondary' title='Add Notes' size='sm'): icon(name='file-text-o')]
       #[b-btn(@click.stop='showFull()' variant='outline-secondary' title='View Full Request' size='sm'): icon(name='search')]
+      #[b-btn(@click.stop='snooze()' variant='outline-secondary' title='Snooze Request' size='sm'): icon(name='clock-o')]
     b-card-body.p-0
       p.card-text.mpj-request-text.mb-1.px-3.pt-3
         | {{ request.text }}
@@ -27,6 +28,11 @@ export default {
     toast: { required: true },
     events: { required: true }
   },
+  computed: {
+    isSnoozed () {
+      return Date.now() < this.request.snoozedUntil
+    }
+  },
   methods: {
     async markPrayed () {
       await this.$store.dispatch(actions.UPDATE_REQUEST, {
@@ -45,6 +51,9 @@ export default {
     },
     showNotes () {
       this.events.$emit('notes', this.request)
+    },
+    snooze () {
+      this.events.$emit('snooze', this.request.requestId)
     }
   }
 }

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

@@ -0,0 +1,72 @@
+<template lang="pug">
+b-modal(v-model='snoozeVisible'
+        header-bg-variant='mpj'
+        header-text-variant='light'
+        size='lg'
+        title='Snooze Prayer Request'
+        @edit='openDialog()')
+  b-form
+    b-form-group(label='Until'
+                 label-for='until')
+      b-input#until(type='date'
+                    v-model='form.snoozedUntil'
+                    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>
+'use strict'
+
+import actions from '@/store/action-types'
+
+export default {
+  name: 'snooze-request',
+  props: {
+    toast: { required: true },
+    events: { required: true }
+  },
+  data () {
+    return {
+      snoozeVisible: false,
+      form: {
+        requestId: '',
+        snoozedUntil: ''
+      }
+    }
+  },
+  created () {
+    this.events.$on('snooze', this.openDialog)
+  },
+  computed: {
+    isValid () {
+      return !isNaN(Date.parse(this.form.snoozedUntil))
+    }
+  },
+  methods: {
+    closeDialog () {
+      this.form.requestId = ''
+      this.form.snoozedUntil = ''
+      this.snoozeVisible = false
+    },
+    openDialog (requestId) {
+      this.form.requestId = requestId
+      this.snoozeVisible = true
+    },
+    async snoozeRequest () {
+      await this.$store.dispatch(actions.SNOOZE_REQUEST, {
+        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.closeDialog()
+    }
+  }
+}
+</script>

src/app/src/main.js

@@ -12,10 +12,12 @@ import 'vue-toast/dist/vue-toast.min.css'
 
 // Only import the icons we need; the whole set is ~500K!
 import 'vue-awesome/icons/check'
+import 'vue-awesome/icons/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'

src/app/src/router/index.js

@@ -7,6 +7,7 @@ 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)
@@ -45,6 +46,11 @@ export default new Router({
       name: 'TermsOfService',
       component: TermsOfService
     },
+    {
+      path: '/snoozed',
+      name: 'Snoozed',
+      component: Snoozed
+    },
     {
       path: '/user/log-on',
       name: 'LogOn',

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

@@ -6,5 +6,7 @@ export default {
   /** Action to load the user's prayer journal */
   LOAD_JOURNAL: 'load-journal',
   /** Action to update a request */
-  UPDATE_REQUEST: 'update-request'
+  UPDATE_REQUEST: 'update-request',
+  /** Action to snooze a request */
+  SNOOZE_REQUEST: 'snooze-request'
 }

src/app/src/store/index.js

@@ -109,6 +109,18 @@ export default new Vuex.Store({
         logError(err)
         progress.fail()
       }
+    },
+    async [actions.SNOOZE_REQUEST] ({ commit }, { progress, requestId, until }) {
+      progress.start()
+      try {
+        await api.snoozeRequest(requestId, until)
+        const request = await api.getRequest(requestId)
+        commit(mutations.REQUEST_UPDATED, request.data)
+        progress.finish()
+      } catch (err) {
+        logError(err)
+        progress.fail()
+      }
     }
   },
   getters: {},