Add slug and upload dest to settings (#2)

- Change how functions are registered

.gitignore

@@ -262,3 +262,6 @@ src/MyWebLog/wwwroot/img/bit-badger
 
 .ionide
 src/MyWebLog/appsettings.Production.json
+
+# SQLite database files
+src/MyWebLog/*.db*

build.fsx

@@ -33,7 +33,6 @@ let version =
 /// Zip a theme distributed with myWebLog
 let zipTheme (name : string) (_ : TargetParameter) =
     let path = $"src/{name}-theme"
-    Trace.log $"Path = {path}"
     !! $"{path}/**/*"
     |> Zip.filesAsSpecs path //$"src/{name}-theme"
     |> Seq.filter (fun (_, name) -> not (name.EndsWith ".zip"))
@@ -79,14 +78,16 @@ Target.create "PackageLinux" (packageFor "linux-x64")
 Target.create "RepackageLinux" (fun _ ->
     let workDir = $"{releasePath}/linux"
     let zipArchive = $"{releasePath}/myWebLog-{version}.linux-x64.zip"
+    let sh command args = 
+        CreateProcess.fromRawCommand command args
+        |> CreateProcess.redirectOutput
+        |> Proc.run
+        |> ignore
     Shell.mkdir workDir
     Zip.unzip workDir zipArchive
     Shell.cd workDir
-    [ "cfj"; $"../myWebLog-{version}.linux-x64.tar.bz2"; "." ]
+    sh "chmod" [ "+x"; "app/MyWebLog" ]
-    |> CreateProcess.fromRawCommand "tar"
+    sh "tar" [ "cfj"; $"../myWebLog-{version}.linux-x64.tar.bz2"; "." ]
-    |> CreateProcess.redirectOutput
-    |> Proc.run
-    |> ignore
     Shell.cd "../.."
     Shell.rm zipArchive
     Shell.rm_rf workDir

src/MyWebLog.Data/Converters.fs

@@ -99,7 +99,21 @@ module Json =
             writer.WriteValue (ThemeId.toString value)
         override _.ReadJson (reader : JsonReader, _ : Type, _ : ThemeId, _ : bool, _ : JsonSerializer) =
             (string >> ThemeId) reader.Value
-        
+    
+    type UploadDestinationConverter () =
+        inherit JsonConverter<UploadDestination> ()
+        override _.WriteJson (writer : JsonWriter, value : UploadDestination, _ : JsonSerializer) =
+            writer.WriteValue (UploadDestination.toString value)
+        override _.ReadJson (reader : JsonReader, _ : Type, _ : UploadDestination, _ : bool, _ : JsonSerializer) =
+            (string >> UploadDestination.parse) reader.Value
+    
+    type UploadIdConverter () =
+        inherit JsonConverter<UploadId> ()
+        override _.WriteJson (writer : JsonWriter, value : UploadId, _ : JsonSerializer) =
+            writer.WriteValue (UploadId.toString value)
+        override _.ReadJson (reader : JsonReader, _ : Type, _ : UploadId, _ : bool, _ : JsonSerializer) =
+            (string >> UploadId) reader.Value
+    
     type WebLogIdConverter () =
         inherit JsonConverter<WebLogId> ()
         override _.WriteJson (writer : JsonWriter, value : WebLogId, _ : JsonSerializer) =
@@ -120,21 +134,23 @@ module Json =
     let all () : JsonConverter seq =
         seq {
             // Our converters
-            CategoryIdConverter       ()
+            CategoryIdConverter        ()
-            CommentIdConverter        ()
+            CommentIdConverter         ()
-            CustomFeedIdConverter     ()
+            CustomFeedIdConverter      ()
-            CustomFeedSourceConverter ()
+            CustomFeedSourceConverter  ()
-            ExplicitRatingConverter   ()
+            ExplicitRatingConverter    ()
-            MarkupTextConverter       ()
+            MarkupTextConverter        ()
-            PermalinkConverter        ()
+            PermalinkConverter         ()
-            PageIdConverter           ()
+            PageIdConverter            ()
-            PodcastMediumConverter    ()
+            PodcastMediumConverter     ()
-            PostIdConverter           ()
+            PostIdConverter            ()
-            TagMapIdConverter         ()
+            TagMapIdConverter          ()
-            ThemeAssetIdConverter     ()
+            ThemeAssetIdConverter      ()
-            ThemeIdConverter          ()
+            ThemeIdConverter           ()
-            WebLogIdConverter         ()
+            UploadDestinationConverter ()
-            WebLogUserIdConverter     ()
+            UploadIdConverter          ()
+            WebLogIdConverter          ()
+            WebLogUserIdConverter      ()
             // Handles DUs with no associated data, as well as option fields
-            CompactUnionJsonConverter ()
+            CompactUnionJsonConverter  ()
         }

src/MyWebLog.Data/Interfaces.fs

@@ -199,6 +199,28 @@ type IThemeAssetData =
     abstract member save : ThemeAsset -> Task<unit>
 
 
+/// Functions to manipulate uploaded files
+type IUploadData =
+    
+    /// Add an uploaded file
+    abstract member add : Upload -> Task<unit>
+    
+    /// Delete an uploaded file
+    abstract member delete : UploadId -> WebLogId -> Task<Result<string, string>>
+    
+    /// Find an uploaded file by its path for the given web log
+    abstract member findByPath : string -> WebLogId -> Task<Upload option>
+    
+    /// Find all uploaded files for a web log (excludes data)
+    abstract member findByWebLog : WebLogId -> Task<Upload list>
+    
+    /// Find all uploaded files for a web log
+    abstract member findByWebLogWithData : WebLogId -> Task<Upload list>
+    
+    /// Restore uploaded files from a backup
+    abstract member restore : Upload list -> Task<unit>
+
+
 /// Functions to manipulate web logs
 type IWebLogData =
     
@@ -270,6 +292,9 @@ type IData =
     /// Theme asset data functions
     abstract member ThemeAsset : IThemeAssetData
     
+    /// Uploaded file functions
+    abstract member Upload : IUploadData
+    
     /// Web log data functions
     abstract member WebLog : IWebLogData
     

src/MyWebLog.Data/MyWebLog.Data.fsproj

@@ -31,6 +31,7 @@
 		<Compile Include="SQLite\SQLitePostData.fs" />
 		<Compile Include="SQLite\SQLiteTagMapData.fs" />
 		<Compile Include="SQLite\SQLiteThemeData.fs" />
+		<Compile Include="SQLite\SQLiteUploadData.fs" />
 		<Compile Include="SQLite\SQLiteWebLogData.fs" />
 		<Compile Include="SQLite\SQLiteWebLogUserData.fs" />
 		<Compile Include="SQLiteData.fs" />

src/MyWebLog.Data/RethinkDbData.fs

@@ -33,6 +33,9 @@ module private RethinkHelpers =
         /// The theme asset table
         let ThemeAsset = "ThemeAsset"
         
+        /// The uploaded file table
+        let Upload = "Upload"
+        
         /// The web log table
         let WebLog = "WebLog"
 
@@ -40,7 +43,7 @@ module private RethinkHelpers =
         let WebLogUser = "WebLogUser"
 
         /// A list of all tables
-        let all = [ Category; Comment; Page; Post; TagMap; Theme; ThemeAsset; WebLog; WebLogUser ]
+        let all = [ Category; Comment; Page; Post; TagMap; Theme; ThemeAsset; Upload; WebLog; WebLogUser ]
 
 
     /// Shorthand for the ReQL starting point
@@ -125,6 +128,15 @@ type RethinkDbData (conn : Net.IConnection, config : DataConfig, log : ILogger<R
                     indexCreate "webLogAndUrl" (fun row -> r.Array (row["webLogId"], row["urlValue"]) :> obj)
                     write; withRetryOnce; ignoreResult conn
                 }
+        // Uploaded files need an index by web log ID and path, as that is how they are retrieved
+        if Table.Upload = table then
+            if not (indexes |> List.contains "webLogAndPath") then
+                log.LogInformation $"Creating index {table}.webLogAndPath..."
+                do! rethink {
+                    withTable table
+                    indexCreate "webLogAndPath" (fun row -> r.Array (row["webLogId"], row["path"]) :> obj)
+                    write; withRetryOnce; ignoreResult conn
+                }
         // Users log on with e-mail
         if Table.WebLogUser = table && not (indexes |> List.contains "logOn") then
             log.LogInformation $"Creating index {table}.logOn..."
@@ -725,6 +737,69 @@ type RethinkDbData (conn : Net.IConnection, config : DataConfig, log : ILogger<R
                 }
         }
         
+        member _.Upload = {
+            new IUploadData with
+                
+                member _.add upload = rethink {
+                    withTable Table.Upload
+                    insert upload
+                    write; withRetryDefault; ignoreResult conn
+                }
+                
+                member _.delete uploadId webLogId = backgroundTask {
+                    let! upload =
+                        rethink<Upload> {
+                            withTable Table.Upload
+                            get uploadId
+                            resultOption; withRetryOptionDefault
+                        }
+                        |> verifyWebLog<Upload> webLogId (fun u -> u.webLogId) <| conn
+                    match upload with
+                    | Some up ->
+                        do! rethink {
+                            withTable Table.Upload
+                            get uploadId
+                            delete
+                            write; withRetryDefault; ignoreResult conn
+                        }
+                        return Ok (Permalink.toString up.path)
+                    | None -> return Result.Error $"Upload ID {UploadId.toString uploadId} not found"
+                }
+                
+                member _.findByPath path webLogId =
+                    rethink<Upload> {
+                        withTable Table.Upload
+                        getAll [ r.Array (webLogId, path) ] "webLogAndPath"
+                        resultCursor; withRetryCursorDefault; toList
+                    }
+                    |> tryFirst <| conn
+                
+                member _.findByWebLog webLogId = rethink<Upload> {
+                    withTable Table.Upload
+                    between (r.Array (webLogId, r.Minval ())) (r.Array (webLogId, r.Maxval ()))
+                        [ Index "webLogAndPath" ]
+                    without [ "data" ]
+                    resultCursor; withRetryCursorDefault; toList conn
+                }
+                
+                member _.findByWebLogWithData webLogId = rethink<Upload> {
+                    withTable Table.Upload
+                    between (r.Array (webLogId, r.Minval ())) (r.Array (webLogId, r.Maxval ()))
+                        [ Index "webLogAndPath" ]
+                    resultCursor; withRetryCursorDefault; toList conn
+                }
+                
+                member _.restore uploads = backgroundTask {
+                    // Files can be large; we'll do 5 at a time
+                    for batch in uploads |> List.chunkBySize 5 do
+                        do! rethink {
+                            withTable Table.TagMap
+                            insert batch
+                            write; withRetryOnce; ignoreResult conn
+                        }
+                }
+        }
+        
         member _.WebLog = {
             new IWebLogData with
                 
@@ -763,6 +838,14 @@ type RethinkDbData (conn : Net.IConnection, config : DataConfig, log : ILogger<R
                          delete
                          write; withRetryOnce; ignoreResult conn
                      }
+                     // Uploaded files do not have a straightforward webLogId index
+                     do! rethink {
+                         withTable Table.Upload
+                         between (r.Array (webLogId, r.Minval ())) (r.Array (webLogId, r.Maxval ()))
+                                     [ Index "webLogAndPath" ]
+                         delete
+                         write; withRetryOnce; ignoreResult conn
+                     }
                      for table in [ Table.Post; Table.Category; Table.Page; Table.WebLogUser ] do
                          do! rethink {
                              withTable table
@@ -805,12 +888,14 @@ type RethinkDbData (conn : Net.IConnection, config : DataConfig, log : ILogger<R
                     get webLog.id
                     update [
                         "name",         webLog.name :> obj
+                        "slug",         webLog.slug
                         "subtitle",     webLog.subtitle
                         "defaultPage",  webLog.defaultPage
                         "postsPerPage", webLog.postsPerPage
                         "timeZone",     webLog.timeZone
                         "themePath",    webLog.themePath
                         "autoHtmx",     webLog.autoHtmx
+                        "uploads",      webLog.uploads
                     ]
                     write; withRetryDefault; ignoreResult conn
                 }
@@ -900,6 +985,7 @@ type RethinkDbData (conn : Net.IConnection, config : DataConfig, log : ILogger<R
             do! ensureIndexes Table.Page       [ "webLogId"; "authorId" ]
             do! ensureIndexes Table.Post       [ "webLogId"; "authorId" ]
             do! ensureIndexes Table.TagMap     []
+            do! ensureIndexes Table.Upload     []
             do! ensureIndexes Table.WebLog     [ "urlBase" ]
             do! ensureIndexes Table.WebLogUser [ "webLogId" ]
         }

src/MyWebLog.Data/SQLite/Helpers.fs

@@ -248,10 +248,28 @@ module Map =
           text = getString "template" rdr
         }
     
+    /// Create an uploaded file from the current row in the given data reader
+    let toUpload includeData (rdr : SqliteDataReader) : Upload =
+        let data =
+            if includeData then
+                use dataStream = new MemoryStream ()
+                use blobStream = getStream "data" rdr
+                blobStream.CopyTo dataStream
+                dataStream.ToArray ()
+            else
+                [||]
+        { id        = UploadId (getString "id" rdr)
+          webLogId  = WebLogId (getString "web_log_id" rdr)
+          path      = Permalink (getString "path" rdr)
+          updatedOn = getDateTime "updated_on" rdr
+          data      = data
+        }
+    
     /// Create a web log from the current row in the given data reader
     let toWebLog (rdr : SqliteDataReader) : WebLog =
         { id           = WebLogId (getString "id" rdr)
           name         = getString "name" rdr
+          slug         = getString "slug" rdr
           subtitle     = tryString "subtitle" rdr
           defaultPage  = getString "default_page" rdr
           postsPerPage = getInt "posts_per_page" rdr
@@ -259,6 +277,7 @@ module Map =
           urlBase      = getString "url_base" rdr
           timeZone     = getString "time_zone" rdr
           autoHtmx     = getBoolean "auto_htmx" rdr
+          uploads      = UploadDestination.parse (getString "uploads" rdr)
           rss          = {
               feedEnabled     = getBoolean "feed_enabled" rdr
               feedName        = getString "feed_name" rdr

src/MyWebLog.Data/SQLite/SQLiteCategoryData.fs

@@ -21,12 +21,12 @@ type SQLiteCategoryData (conn : SqliteConnection) =
     /// Add a category
     let add cat = backgroundTask {
         use cmd = conn.CreateCommand ()
-        cmd.CommandText <-
+        cmd.CommandText <- """
-            """INSERT INTO category (
+            INSERT INTO category (
-                   id, web_log_id, name, slug, description, parent_id
+                id, web_log_id, name, slug, description, parent_id
-               ) VALUES (
+            ) VALUES (
-                   @id, @webLogId, @name, @slug, @description, @parentId
+                @id, @webLogId, @name, @slug, @description, @parentId
-               )"""
+            )"""
         addCategoryParameters cmd cat
         let! _ = cmd.ExecuteNonQueryAsync ()
         ()
@@ -70,13 +70,13 @@ type SQLiteCategoryData (conn : SqliteConnection) =
                 // Parent category post counts include posts in subcategories
                 cmd.Parameters.Clear ()
                 addWebLogId cmd webLogId
-                cmd.CommandText <-
+                cmd.CommandText <- """
-                    """SELECT COUNT(DISTINCT p.id)
+                    SELECT COUNT(DISTINCT p.id)
-                         FROM post p
+                      FROM post p
-                              INNER JOIN post_category pc ON pc.post_id = p.id
+                           INNER JOIN post_category pc ON pc.post_id = p.id
-                        WHERE p.web_log_id = @webLogId
+                     WHERE p.web_log_id = @webLogId
-                          AND p.status     = 'Published'
+                       AND p.status     = 'Published'
-                          AND pc.category_id IN ("""
+                       AND pc.category_id IN ("""
                 ordered
                 |> Seq.filter (fun cat -> cat.parentNames |> Array.contains it.name)
                 |> Seq.map (fun cat -> cat.id)
@@ -125,10 +125,10 @@ type SQLiteCategoryData (conn : SqliteConnection) =
         | Some _ ->
             use cmd = conn.CreateCommand ()
             // Delete the category off all posts where it is assigned
-            cmd.CommandText <-
+            cmd.CommandText <- """
-                """DELETE FROM post_category
+                DELETE FROM post_category
-                    WHERE category_id = @id
+                 WHERE category_id = @id
-                      AND post_id IN (SELECT id FROM post WHERE web_log_id = @webLogId)"""
+                   AND post_id IN (SELECT id FROM post WHERE web_log_id = @webLogId)"""
             let catIdParameter = cmd.Parameters.AddWithValue ("@id", CategoryId.toString catId)
             cmd.Parameters.AddWithValue ("@webLogId", WebLogId.toString webLogId) |> ignore
             do! write cmd
@@ -150,14 +150,14 @@ type SQLiteCategoryData (conn : SqliteConnection) =
     /// Update a category
     let update cat = backgroundTask {
         use cmd = conn.CreateCommand ()
-        cmd.CommandText <-
+        cmd.CommandText <- """
-            """UPDATE category
+            UPDATE category
-                  SET name        = @name,
+               SET name        = @name,
-                      slug        = @slug,
+                   slug        = @slug,
-                      description = @description,
+                   description = @description,
-                      parent_id   = @parentId
+                   parent_id   = @parentId
-                WHERE id         = @id
+             WHERE id         = @id
-                  AND web_log_id = @webLogId"""
+               AND web_log_id = @webLogId"""
         addCategoryParameters cmd cat
         do! write cmd
     }

src/MyWebLog.Data/SQLite/SQLitePageData.fs

@@ -139,14 +139,14 @@ type SQLitePageData (conn : SqliteConnection) =
     let add page = backgroundTask {
         use cmd = conn.CreateCommand ()
         // The page itself
-        cmd.CommandText <-
+        cmd.CommandText <- """
-            """INSERT INTO page (
+            INSERT INTO page (
-                   id, web_log_id, author_id, title, permalink, published_on, updated_on, show_in_page_list,
+                id, web_log_id, author_id, title, permalink, published_on, updated_on, show_in_page_list, template,
-                   template, page_text
+                page_text
-               ) VALUES (
+            ) VALUES (
-                   @id, @webLogId, @authorId, @title, @permalink, @publishedOn, @updatedOn, @showInPageList,
+                @id, @webLogId, @authorId, @title, @permalink, @publishedOn, @updatedOn, @showInPageList, @template,
-                   @template, @text
+                @text
-               )"""
+            )"""
         addPageParameters cmd page
         do! write cmd
         do! updatePageMeta       page.id [] page.metadata
@@ -174,11 +174,11 @@ type SQLitePageData (conn : SqliteConnection) =
     /// Count all pages shown in the page list for the given web log
     let countListed webLogId = backgroundTask {
         use cmd = conn.CreateCommand ()
-        cmd.CommandText <-
+        cmd.CommandText <- """
-            """SELECT COUNT(id)
+            SELECT COUNT(id)
-                 FROM page
+              FROM page
-                WHERE web_log_id        = @webLogId
+             WHERE web_log_id        = @webLogId
-                  AND show_in_page_list = @showInPageList"""
+               AND show_in_page_list = @showInPageList"""
         addWebLogId cmd webLogId
         cmd.Parameters.AddWithValue ("@showInPageList", true) |> ignore
         return! count cmd
@@ -211,11 +211,11 @@ type SQLitePageData (conn : SqliteConnection) =
         | Some _ ->
             use cmd = conn.CreateCommand ()
             cmd.Parameters.AddWithValue ("@id", PageId.toString pageId) |> ignore
-            cmd.CommandText <-
+            cmd.CommandText <- """
-                """DELETE FROM page_revision  WHERE page_id = @id;
+                DELETE FROM page_revision  WHERE page_id = @id;
-                   DELETE FROM page_permalink WHERE page_id = @id;
+                DELETE FROM page_permalink WHERE page_id = @id;
-                   DELETE FROM page_meta      WHERE page_id = @id;
+                DELETE FROM page_meta      WHERE page_id = @id;
-                   DELETE FROM page           WHERE id      = @id"""
+                DELETE FROM page           WHERE id      = @id"""
             do! write cmd
             return true
         | None -> return false
@@ -238,12 +238,12 @@ type SQLitePageData (conn : SqliteConnection) =
     /// Find the current permalink within a set of potential prior permalinks for the given web log
     let findCurrentPermalink permalinks webLogId = backgroundTask {
         use cmd = conn.CreateCommand ()
-        cmd.CommandText <-
+        cmd.CommandText <- """
-            """SELECT p.permalink
+            SELECT p.permalink
-                 FROM page p
+              FROM page p
-                      INNER JOIN page_permalink pp ON pp.page_id = p.id
+                   INNER JOIN page_permalink pp ON pp.page_id = p.id
-                WHERE p.web_log_id = @webLogId
+             WHERE p.web_log_id = @webLogId
-                  AND pp.permalink IN ("""
+               AND pp.permalink IN ("""
         permalinks
         |> List.iteri (fun idx link ->
             if idx > 0 then cmd.CommandText <- $"{cmd.CommandText}, "
@@ -274,12 +274,12 @@ type SQLitePageData (conn : SqliteConnection) =
     /// Get all listed pages for the given web log (without revisions, prior permalinks, or text)
     let findListed webLogId = backgroundTask {
         use cmd = conn.CreateCommand ()
-        cmd.CommandText <-
+        cmd.CommandText <- """
-            """SELECT *
+            SELECT *
-                 FROM page
+              FROM page
-                WHERE web_log_id        = @webLogId
+             WHERE web_log_id        = @webLogId
-                  AND show_in_page_list = @showInPageList
+               AND show_in_page_list = @showInPageList
-                ORDER BY LOWER(title)"""
+             ORDER BY LOWER(title)"""
         addWebLogId cmd webLogId
         cmd.Parameters.AddWithValue ("@showInPageList", true) |> ignore
         use! rdr = cmd.ExecuteReaderAsync ()
@@ -293,12 +293,12 @@ type SQLitePageData (conn : SqliteConnection) =
     /// Get a page of pages for the given web log (without revisions, prior permalinks, or metadata)
     let findPageOfPages webLogId pageNbr = backgroundTask {
         use cmd = conn.CreateCommand ()
-        cmd.CommandText <-
+        cmd.CommandText <- """
-            """SELECT *
+            SELECT *
-                 FROM page
+              FROM page
-                WHERE web_log_id = @webLogId
+             WHERE web_log_id = @webLogId
-                ORDER BY LOWER(title)
+             ORDER BY LOWER(title)
-                LIMIT @pageSize OFFSET @toSkip"""
+             LIMIT @pageSize OFFSET @toSkip"""
         addWebLogId cmd webLogId
         [ cmd.Parameters.AddWithValue ("@pageSize", 26)
           cmd.Parameters.AddWithValue ("@toSkip", (pageNbr - 1) * 25)
@@ -318,18 +318,18 @@ type SQLitePageData (conn : SqliteConnection) =
         match! findFullById page.id page.webLogId with
         | Some oldPage ->
             use cmd = conn.CreateCommand ()
-            cmd.CommandText <-
+            cmd.CommandText <- """
-                """UPDATE page
+                UPDATE page
-                      SET author_id         = @authorId,
+                   SET author_id         = @authorId,
-                          title             = @title,
+                       title             = @title,
-                          permalink         = @permalink,
+                       permalink         = @permalink,
-                          published_on      = @publishedOn,
+                       published_on      = @publishedOn,
-                          updated_on        = @updatedOn,
+                       updated_on        = @updatedOn,
-                          show_in_page_list = @showInPageList,
+                       show_in_page_list = @showInPageList,
-                          template          = @template,
+                       template          = @template,
-                          page_text         = @text
+                       page_text         = @text
-                    WHERE id         = @pageId
+                 WHERE id         = @pageId
-                      AND web_log_id = @webLogId"""
+                   AND web_log_id = @webLogId"""
             addPageParameters cmd page
             do! write cmd
             do! updatePageMeta       page.id oldPage.metadata        page.metadata

src/MyWebLog.Data/SQLite/SQLitePostData.fs

@@ -146,26 +146,26 @@ type SQLitePostData (conn : SqliteConnection) =
         if count = 1 then
             match post.episode with
             | Some ep ->
-                cmd.CommandText <-
+                cmd.CommandText <- """
-                    """UPDATE post_episode
+                    UPDATE post_episode
-                          SET media               = @media,
+                       SET media               = @media,
-                              length              = @length,
+                           length              = @length,
-                              duration            = @duration,
+                           duration            = @duration,
-                              media_type          = @mediaType,
+                           media_type          = @mediaType,
-                              image_url           = @imageUrl,
+                           image_url           = @imageUrl,
-                              subtitle            = @subtitle,
+                           subtitle            = @subtitle,
-                              explicit            = @explicit,
+                           explicit            = @explicit,
-                              chapter_file        = @chapterFile,
+                           chapter_file        = @chapterFile,
-                              chapter_type        = @chapterType,
+                           chapter_type        = @chapterType,
-                              transcript_url      = @transcriptUrl,
+                           transcript_url      = @transcriptUrl,
-                              transcript_type     = @transcriptType,
+                           transcript_type     = @transcriptType,
-                              transcript_lang     = @transcriptLang,
+                           transcript_lang     = @transcriptLang,
-                              transcript_captions = @transcriptCaptions,
+                           transcript_captions = @transcriptCaptions,
-                              season_number       = @seasonNumber,
+                           season_number       = @seasonNumber,
-                              season_description  = @seasonDescription,
+                           season_description  = @seasonDescription,
-                              episode_number      = @episodeNumber,
+                           episode_number      = @episodeNumber,
-                              episode_description = @episodeDescription
+                           episode_description = @episodeDescription
-                        WHERE post_id = @postId"""
+                     WHERE post_id = @postId"""
                 addEpisodeParameters cmd ep
                 do! write cmd
             | None ->
@@ -174,16 +174,16 @@ type SQLitePostData (conn : SqliteConnection) =
         else
             match post.episode with
             | Some ep ->
-                cmd.CommandText <-
+                cmd.CommandText <- """
-                    """INSERT INTO post_episode (
+                    INSERT INTO post_episode (
-                           post_id, media, length, duration, media_type, image_url, subtitle, explicit,
+                        post_id, media, length, duration, media_type, image_url, subtitle, explicit, chapter_file,
-                           chapter_file, chapter_type, transcript_url, transcript_type, transcript_lang,
+                        chapter_type, transcript_url, transcript_type, transcript_lang, transcript_captions,
-                           transcript_captions, season_number, season_description, episode_number, episode_description
+                        season_number, season_description, episode_number, episode_description
-                       ) VALUES (
+                    ) VALUES (
-                           @postId, @media, @length, @duration, @mediaType, @imageUrl, @subtitle, @explicit,
+                        @postId, @media, @length, @duration, @mediaType, @imageUrl, @subtitle, @explicit, @chapterFile,
-                           @chapterFile, @chapterType, @transcriptUrl, @transcriptType, @transcriptLang,
+                        @chapterType, @transcriptUrl, @transcriptType, @transcriptLang, @transcriptCaptions,
-                           @transcriptCaptions, @seasonNumber, @seasonDescription, @episodeNumber, @episodeDescription
+                        @seasonNumber, @seasonDescription, @episodeNumber, @episodeDescription
-                       )"""
+                    )"""
                 addEpisodeParameters cmd ep
                 do! write cmd
             | None -> ()
@@ -278,14 +278,12 @@ type SQLitePostData (conn : SqliteConnection) =
     /// Add a post
     let add post = backgroundTask {
         use cmd = conn.CreateCommand ()
-        cmd.CommandText <-
+        cmd.CommandText <- """
-            """INSERT INTO post (
+            INSERT INTO post (
-                   id, web_log_id, author_id, status, title, permalink, published_on, updated_on,
+                id, web_log_id, author_id, status, title, permalink, published_on, updated_on, template, post_text
-                   template, post_text
+            ) VALUES (
-               ) VALUES (
+                @id, @webLogId, @authorId, @status, @title, @permalink, @publishedOn, @updatedOn, @template, @text
-                   @id, @webLogId, @authorId, @status, @title, @permalink, @publishedOn, @updatedOn,
+            )"""
-                   @template, @text
-               )"""
         addPostParameters cmd post
         do! write cmd
         do! updatePostCategories post.id [] post.categoryIds
@@ -340,14 +338,14 @@ type SQLitePostData (conn : SqliteConnection) =
         | Some _ ->
             use cmd = conn.CreateCommand ()
             cmd.Parameters.AddWithValue ("@id", PostId.toString postId) |> ignore
-            cmd.CommandText <-
+            cmd.CommandText <- """
-                """DELETE FROM post_revision  WHERE post_id = @id;
+                DELETE FROM post_revision  WHERE post_id = @id;
-                   DELETE FROM post_permalink WHERE post_id = @id;
+                DELETE FROM post_permalink WHERE post_id = @id;
-                   DELETE FROM post_meta      WHERE post_id = @id;
+                DELETE FROM post_meta      WHERE post_id = @id;
-                   DELETE FROM post_episode   WHERE post_id = @id;
+                DELETE FROM post_episode   WHERE post_id = @id;
-                   DELETE FROM post_tag       WHERE post_id = @id;
+                DELETE FROM post_tag       WHERE post_id = @id;
-                   DELETE FROM post_category  WHERE post_id = @id;
+                DELETE FROM post_category  WHERE post_id = @id;
-                   DELETE FROM post           WHERE id      = @id"""
+                DELETE FROM post           WHERE id      = @id"""
             do! write cmd
             return true
         | None -> return false
@@ -356,12 +354,12 @@ type SQLitePostData (conn : SqliteConnection) =
     /// Find the current permalink from a list of potential prior permalinks for the given web log
     let findCurrentPermalink permalinks webLogId = backgroundTask {
         use cmd = conn.CreateCommand ()
-        cmd.CommandText <-
+        cmd.CommandText <- """
-            """SELECT p.permalink
+            SELECT p.permalink
-                 FROM post p
+              FROM post p
-                      INNER JOIN post_permalink pp ON pp.post_id = p.id
+                   INNER JOIN post_permalink pp ON pp.post_id = p.id
-                WHERE p.web_log_id = @webLogId
+             WHERE p.web_log_id = @webLogId
-                  AND pp.permalink IN ("""
+               AND pp.permalink IN ("""
         permalinks
         |> List.iteri (fun idx link ->
             if idx > 0 then cmd.CommandText <- $"{cmd.CommandText}, "
@@ -392,12 +390,12 @@ type SQLitePostData (conn : SqliteConnection) =
     /// Get a page of categorized posts for the given web log (excludes revisions and prior permalinks)
     let findPageOfCategorizedPosts webLogId categoryIds pageNbr postsPerPage = backgroundTask {
         use cmd = conn.CreateCommand ()
-        cmd.CommandText <-
+        cmd.CommandText <- $"""
-            $"""{selectPost}
+            {selectPost}
-                      INNER JOIN post_category pc ON pc.post_id = p.id
+                   INNER JOIN post_category pc ON pc.post_id = p.id
-                WHERE p.web_log_id = @webLogId
+             WHERE p.web_log_id = @webLogId
-                  AND p.status     = @status
+               AND p.status     = @status
-                  AND pc.category_id IN ("""
+               AND pc.category_id IN ("""
         categoryIds
         |> List.iteri (fun idx catId ->
             if idx > 0 then cmd.CommandText <- $"{cmd.CommandText}, "
@@ -420,11 +418,11 @@ type SQLitePostData (conn : SqliteConnection) =
     /// Get a page of posts for the given web log (excludes text, revisions, and prior permalinks)
     let findPageOfPosts webLogId pageNbr postsPerPage = backgroundTask {
         use cmd = conn.CreateCommand ()
-        cmd.CommandText <-
+        cmd.CommandText <- $"""
-            $"""{selectPost}
+            {selectPost}
-                 WHERE p.web_log_id = @webLogId
+              WHERE p.web_log_id = @webLogId
-                 ORDER BY p.published_on DESC NULLS FIRST, p.updated_on
+              ORDER BY p.published_on DESC NULLS FIRST, p.updated_on
-                 LIMIT {postsPerPage + 1} OFFSET {(pageNbr - 1) * postsPerPage}"""
+              LIMIT {postsPerPage + 1} OFFSET {(pageNbr - 1) * postsPerPage}"""
         addWebLogId cmd webLogId
         use! rdr = cmd.ExecuteReaderAsync ()
         let! posts =
@@ -437,12 +435,12 @@ type SQLitePostData (conn : SqliteConnection) =
     /// Get a page of published posts for the given web log (excludes revisions and prior permalinks)
     let findPageOfPublishedPosts webLogId pageNbr postsPerPage = backgroundTask {
         use cmd = conn.CreateCommand ()
-        cmd.CommandText <-
+        cmd.CommandText <- $"""
-            $"""{selectPost}
+            {selectPost}
-                 WHERE p.web_log_id = @webLogId
+              WHERE p.web_log_id = @webLogId
-                   AND p.status     = @status
+                AND p.status     = @status
-                 ORDER BY p.published_on DESC
+              ORDER BY p.published_on DESC
-                 LIMIT {postsPerPage + 1} OFFSET {(pageNbr - 1) * postsPerPage}"""
+              LIMIT {postsPerPage + 1} OFFSET {(pageNbr - 1) * postsPerPage}"""
         addWebLogId cmd webLogId
         cmd.Parameters.AddWithValue ("@status", PostStatus.toString Published) |> ignore
         use! rdr = cmd.ExecuteReaderAsync ()
@@ -456,14 +454,14 @@ type SQLitePostData (conn : SqliteConnection) =
     /// Get a page of tagged posts for the given web log (excludes revisions and prior permalinks)
     let findPageOfTaggedPosts webLogId (tag : string) pageNbr postsPerPage = backgroundTask {
         use cmd = conn.CreateCommand ()
-        cmd.CommandText <-
+        cmd.CommandText <- $"""
-            $"""{selectPost}
+            {selectPost}
-                       INNER JOIN post_tag pt ON pt.post_id = p.id
+                    INNER JOIN post_tag pt ON pt.post_id = p.id
-                 WHERE p.web_log_id = @webLogId
+              WHERE p.web_log_id = @webLogId
-                   AND p.status     = @status
+                AND p.status     = @status
-                   AND pt.tag       = @tag
+                AND pt.tag       = @tag
-                 ORDER BY p.published_on DESC
+              ORDER BY p.published_on DESC
-                 LIMIT {postsPerPage + 1} OFFSET {(pageNbr - 1) * postsPerPage}"""
+              LIMIT {postsPerPage + 1} OFFSET {(pageNbr - 1) * postsPerPage}"""
         addWebLogId cmd webLogId
         [ cmd.Parameters.AddWithValue ("@status", PostStatus.toString Published)
           cmd.Parameters.AddWithValue ("@tag", tag)
@@ -479,13 +477,13 @@ type SQLitePostData (conn : SqliteConnection) =
     /// Find the next newest and oldest post from a publish date for the given web log
     let findSurroundingPosts webLogId (publishedOn : DateTime) = backgroundTask {
         use cmd = conn.CreateCommand ()
-        cmd.CommandText <-
+        cmd.CommandText <- $"""
-            $"""{selectPost}
+            {selectPost}
-                WHERE p.web_log_id   = @webLogId
+             WHERE p.web_log_id   = @webLogId
-                  AND p.status       = @status
+               AND p.status       = @status
-                  AND p.published_on < @publishedOn
+               AND p.published_on < @publishedOn
-                ORDER BY p.published_on DESC
+             ORDER BY p.published_on DESC
-                LIMIT 1"""
+             LIMIT 1"""
         addWebLogId cmd webLogId
         [ cmd.Parameters.AddWithValue ("@status", PostStatus.toString Published)
           cmd.Parameters.AddWithValue ("@publishedOn", publishedOn)
@@ -499,13 +497,13 @@ type SQLitePostData (conn : SqliteConnection) =
                 return None
         }
         do! rdr.CloseAsync ()
-        cmd.CommandText <-
+        cmd.CommandText <- $"""
-            $"""{selectPost}
+            {selectPost}
-                WHERE p.web_log_id   = @webLogId
+             WHERE p.web_log_id   = @webLogId
-                  AND p.status       = @status
+               AND p.status       = @status
-                  AND p.published_on > @publishedOn
+               AND p.published_on > @publishedOn
-                ORDER BY p.published_on
+             ORDER BY p.published_on
-                LIMIT 1"""
+             LIMIT 1"""
         use! rdr = cmd.ExecuteReaderAsync ()
         let! newer = backgroundTask {
             if rdr.Read () then
@@ -528,18 +526,18 @@ type SQLitePostData (conn : SqliteConnection) =
         match! findFullById post.id post.webLogId with
         | Some oldPost ->
             use cmd = conn.CreateCommand ()
-            cmd.CommandText <-
+            cmd.CommandText <- """
-                """UPDATE post
+                UPDATE post
-                      SET author_id    = @authorId,
+                   SET author_id    = @authorId,
-                          status       = @status,
+                       status       = @status,
-                          title        = @title,
+                       title        = @title,
-                          permalink    = @permalink,
+                       permalink    = @permalink,
-                          published_on = @publishedOn,
+                       published_on = @publishedOn,
-                          updated_on   = @updatedOn,
+                       updated_on   = @updatedOn,
-                          template     = @template,
+                       template     = @template,
-                          post_text    = @text
+                       post_text    = @text
-                    WHERE id         = @id
+                 WHERE id         = @id
-                      AND web_log_id = @webLogId"""
+                   AND web_log_id = @webLogId"""
             addPostParameters cmd post
             do! write cmd
             do! updatePostCategories post.id oldPost.categoryIds     post.categoryIds

src/MyWebLog.Data/SQLite/SQLiteTagMapData.fs

@@ -50,11 +50,11 @@ type SQLiteTagMapData (conn : SqliteConnection) =
     /// Find any tag mappings in a list of tags for the given web log
     let findMappingForTags (tags : string list) webLogId = backgroundTask {
         use cmd = conn.CreateCommand ()
-        cmd.CommandText <-
+        cmd.CommandText <- """
-            """SELECT *
+            SELECT *
-                 FROM tag_map
+              FROM tag_map
-                WHERE web_log_id = @webLogId
+             WHERE web_log_id = @webLogId
-                  AND tag IN ("""
+               AND tag IN ("""
         tags
         |> List.iteri (fun idx tag ->
             if idx > 0 then cmd.CommandText <- $"{cmd.CommandText}, "
@@ -71,19 +71,19 @@ type SQLiteTagMapData (conn : SqliteConnection) =
         use cmd = conn.CreateCommand ()
         match! findById tagMap.id tagMap.webLogId with
         | Some _ ->
-            cmd.CommandText <-
+            cmd.CommandText <- """
-                """UPDATE tag_map
+                UPDATE tag_map
-                      SET tag       = @tag,
+                   SET tag       = @tag,
-                          url_value = @urlValue
+                       url_value = @urlValue
-                    WHERE id         = @id
+                 WHERE id         = @id
-                      AND web_log_id = @webLogId"""
+                   AND web_log_id = @webLogId"""
         | None ->
-            cmd.CommandText <-
+            cmd.CommandText <- """
-                """INSERT INTO tag_map (
+                INSERT INTO tag_map (
-                       id, web_log_id, tag, url_value
+                    id, web_log_id, tag, url_value
-                   ) VALUES (
+                ) VALUES (
-                       @id, @webLogId, @tag, @urlValue
+                    @id, @webLogId, @tag, @urlValue
-                   )"""
+                )"""
         addWebLogId cmd tagMap.webLogId
         [ cmd.Parameters.AddWithValue ("@id", TagMapId.toString tagMap.id)
           cmd.Parameters.AddWithValue ("@tag", tagMap.tag)

src/MyWebLog.Data/SQLite/SQLiteUploadData.fs

@@ -0,0 +1,101 @@
+namespace MyWebLog.Data.SQLite
+
+open System.IO
+open Microsoft.Data.Sqlite
+open MyWebLog
+open MyWebLog.Data
+
+/// SQLite myWebLog web log data implementation        
+type SQLiteUploadData (conn : SqliteConnection) =
+
+    /// Add parameters for uploaded file INSERT and UPDATE statements
+    let addUploadParameters (cmd : SqliteCommand) (upload : Upload) =
+        [ cmd.Parameters.AddWithValue ("@id", UploadId.toString upload.id)
+          cmd.Parameters.AddWithValue ("@webLogId", WebLogId.toString upload.webLogId)
+          cmd.Parameters.AddWithValue ("@path", Permalink.toString upload.path)
+          cmd.Parameters.AddWithValue ("@updatedOn", upload.updatedOn)
+          cmd.Parameters.AddWithValue ("@dataLength", upload.data.Length)
+        ] |> ignore
+    
+    /// Save an uploaded file
+    let add upload = backgroundTask {
+        use cmd = conn.CreateCommand ()
+        cmd.CommandText <- """
+            INSERT INTO upload (
+                id, web_log_id, path, updated_on, data
+            ) VALUES (
+                @id, @webLogId, @path, @updatedOn, ZEROBLOB(@dataLength)
+            )"""
+        addUploadParameters cmd upload
+        do! write cmd
+        
+        cmd.CommandText <- "SELECT ROWID FROM upload WHERE id = @id"
+        let! rowId = cmd.ExecuteScalarAsync ()
+        
+        use dataStream = new MemoryStream (upload.data)
+        use blobStream = new SqliteBlob (conn, "upload", "data", rowId :?> int64)
+        do! dataStream.CopyToAsync blobStream
+    }
+    
+    /// Delete an uploaded file by its ID
+    let delete uploadId webLogId = backgroundTask {
+        use cmd = conn.CreateCommand ()
+        cmd.CommandText <- """
+            SELECT id, web_log_id, path, updated_on
+              FROM upload
+             WHERE id         = @id
+               AND web_log_id = @webLogId"""
+        addWebLogId cmd webLogId
+        cmd.Parameters.AddWithValue ("@id", UploadId.toString uploadId) |> ignore
+        let! rdr = cmd.ExecuteReaderAsync ()
+        if (rdr.Read ()) then
+            let upload = Map.toUpload false rdr
+            do! rdr.CloseAsync ()
+            cmd.CommandText <- "DELETE FROM upload WHERE id = @id AND web_log_id = @webLogId"
+            do! write cmd
+            return Ok (Permalink.toString upload.path)
+        else
+            return Error $"""Upload ID {cmd.Parameters["@id"]} not found"""
+    }
+    
+    /// Find an uploaded file by its path for the given web log
+    let findByPath (path : string) webLogId = backgroundTask {
+        use cmd = conn.CreateCommand ()
+        cmd.CommandText <- "SELECT *, ROWID FROM upload WHERE web_log_id = @webLogId AND path = @path"
+        addWebLogId cmd webLogId
+        cmd.Parameters.AddWithValue ("@path", path) |> ignore
+        let! rdr = cmd.ExecuteReaderAsync ()
+        return if rdr.Read () then Some (Map.toUpload true rdr) else None
+    }
+    
+    /// Find all uploaded files for the given web log (excludes data)
+    let findByWebLog webLogId = backgroundTask {
+        use cmd = conn.CreateCommand ()
+        cmd.CommandText <- "SELECT id, web_log_id, path, updated_on FROM upload WHERE web_log_id = @webLogId"
+        addWebLogId cmd webLogId
+        let! rdr = cmd.ExecuteReaderAsync ()
+        return toList (Map.toUpload false) rdr
+    }
+    
+    /// Find all uploaded files for the given web log
+    let findByWebLogWithData webLogId = backgroundTask {
+        use cmd = conn.CreateCommand ()
+        cmd.CommandText <- "SELECT *, ROWID FROM upload WHERE web_log_id = @webLogId"
+        addWebLogId cmd webLogId
+        let! rdr = cmd.ExecuteReaderAsync ()
+        return toList (Map.toUpload true) rdr
+    }
+    
+    /// Restore uploads from a backup
+    let restore uploads = backgroundTask {
+        for upload in uploads do do! add upload
+    }
+    
+    interface IUploadData with
+        member _.add upload = add upload
+        member _.delete uploadId webLogId = delete uploadId webLogId
+        member _.findByPath path webLogId = findByPath path webLogId
+        member _.findByWebLog webLogId = findByWebLog webLogId
+        member _.findByWebLogWithData webLogId = findByWebLogWithData webLogId
+        member _.restore uploads = restore uploads
+        

src/MyWebLog.Data/SQLite/SQLiteWebLogData.fs

@@ -27,6 +27,7 @@ type SQLiteWebLogData (conn : SqliteConnection) =
     let addWebLogParameters (cmd : SqliteCommand) (webLog : WebLog) =
         [ cmd.Parameters.AddWithValue ("@id", WebLogId.toString webLog.id)
           cmd.Parameters.AddWithValue ("@name", webLog.name)
+          cmd.Parameters.AddWithValue ("@slug", webLog.slug)
           cmd.Parameters.AddWithValue ("@subtitle", maybe webLog.subtitle)
           cmd.Parameters.AddWithValue ("@defaultPage", webLog.defaultPage)
           cmd.Parameters.AddWithValue ("@postsPerPage", webLog.postsPerPage)
@@ -34,6 +35,7 @@ type SQLiteWebLogData (conn : SqliteConnection) =
           cmd.Parameters.AddWithValue ("@urlBase", webLog.urlBase)
           cmd.Parameters.AddWithValue ("@timeZone", webLog.timeZone)
           cmd.Parameters.AddWithValue ("@autoHtmx", webLog.autoHtmx)
+          cmd.Parameters.AddWithValue ("@uploads", UploadDestination.toString webLog.uploads)
         ] |> ignore
         addWebLogRssParameters cmd webLog
     
@@ -69,11 +71,11 @@ type SQLiteWebLogData (conn : SqliteConnection) =
     /// Get the current custom feeds for a web log
     let getCustomFeeds (webLog : WebLog) = backgroundTask {
         use cmd = conn.CreateCommand ()
-        cmd.CommandText <-
+        cmd.CommandText <- """
-            """SELECT f.*, p.*
+            SELECT f.*, p.*
-                 FROM web_log_feed f
+              FROM web_log_feed f
-                      LEFT JOIN web_log_feed_podcast p ON p.feed_id = f.id
+                   LEFT JOIN web_log_feed_podcast p ON p.feed_id = f.id
-                WHERE f.web_log_id = @webLogId"""
+             WHERE f.web_log_id = @webLogId"""
         addWebLogId cmd webLog.id
         use! rdr = cmd.ExecuteReaderAsync ()
         return toList Map.toCustomFeed rdr
@@ -88,16 +90,16 @@ type SQLiteWebLogData (conn : SqliteConnection) =
     /// Add a podcast to a custom feed
     let addPodcast feedId (podcast : PodcastOptions) = backgroundTask {
         use cmd = conn.CreateCommand ()
-        cmd.CommandText <-
+        cmd.CommandText <- """
-            """INSERT INTO web_log_feed_podcast (
+            INSERT INTO web_log_feed_podcast (
-                   feed_id, title, subtitle, items_in_feed, summary, displayed_author, email,
+                feed_id, title, subtitle, items_in_feed, summary, displayed_author, email, image_url,
-                   image_url, itunes_category, itunes_subcategory, explicit, default_media_type,
+                itunes_category, itunes_subcategory, explicit, default_media_type, media_base_url, guid, funding_url,
-                   media_base_url, guid, funding_url, funding_text, medium
+                funding_text, medium
-               ) VALUES (
+            ) VALUES (
-                   @feedId, @title, @subtitle, @itemsInFeed, @summary, @displayedAuthor, @email,
+                @feedId, @title, @subtitle, @itemsInFeed, @summary, @displayedAuthor, @email, @imageUrl,
-                   @imageUrl, @iTunesCategory, @iTunesSubcategory, @explicit, @defaultMediaType,
+                @iTunesCategory, @iTunesSubcategory, @explicit, @defaultMediaType, @mediaBaseUrl, @guid, @fundingUrl,
-                   @mediaBaseUrl, @guid, @fundingUrl, @fundingText, @medium
+                @fundingText, @medium
-               )"""
+            )"""
         addPodcastParameters cmd feedId podcast
         do! write cmd
     }
@@ -115,9 +117,9 @@ type SQLiteWebLogData (conn : SqliteConnection) =
         cmd.Parameters.Add ("@id", SqliteType.Text) |> ignore
         toDelete
         |> List.map (fun it -> backgroundTask {
-            cmd.CommandText <-
+            cmd.CommandText <- """
-                """DELETE FROM web_log_feed_podcast WHERE feed_id = @id;
+                DELETE FROM web_log_feed_podcast WHERE feed_id = @id;
-                   DELETE FROM web_log_feed         WHERE id      = @id"""
+                DELETE FROM web_log_feed         WHERE id      = @id"""
             cmd.Parameters["@id"].Value <- CustomFeedId.toString it.id
             do! write cmd
         })
@@ -126,12 +128,12 @@ type SQLiteWebLogData (conn : SqliteConnection) =
         cmd.Parameters.Clear ()
         toAdd
         |> List.map (fun it -> backgroundTask {
-            cmd.CommandText <-
+            cmd.CommandText <- """
-                """INSERT INTO web_log_feed (
+                INSERT INTO web_log_feed (
-                       id, web_log_id, source, path
+                    id, web_log_id, source, path
-                   ) VALUES (
+                ) VALUES (
-                       @id, @webLogId, @source, @path
+                    @id, @webLogId, @source, @path
-                   )"""
+                )"""
             cmd.Parameters.Clear ()
             addCustomFeedParameters cmd webLog.id it
             do! write cmd
@@ -143,12 +145,12 @@ type SQLiteWebLogData (conn : SqliteConnection) =
         |> ignore
         toUpdate
         |> List.map (fun it -> backgroundTask {
-            cmd.CommandText <-
+            cmd.CommandText <- """
-                """UPDATE web_log_feed
+                UPDATE web_log_feed
-                      SET source = @source,
+                   SET source = @source,
-                          path   = @path
+                       path   = @path
-                    WHERE id         = @id
+                 WHERE id         = @id
-                      AND web_log_id = @webLogId"""
+                   AND web_log_id = @webLogId"""
             cmd.Parameters.Clear ()
             addCustomFeedParameters cmd webLog.id it
             do! write cmd
@@ -156,25 +158,25 @@ type SQLiteWebLogData (conn : SqliteConnection) =
             match it.podcast with
             | Some podcast ->
                 if hadPodcast then
-                    cmd.CommandText <-
+                    cmd.CommandText <- """
-                        """UPDATE web_log_feed_podcast
+                        UPDATE web_log_feed_podcast
-                              SET title              = @title,
+                           SET title              = @title,
-                                  subtitle           = @subtitle,
+                               subtitle           = @subtitle,
-                                  items_in_feed      = @itemsInFeed,
+                               items_in_feed      = @itemsInFeed,
-                                  summary            = @summary,
+                               summary            = @summary,
-                                  displayed_author   = @displayedAuthor,
+                               displayed_author   = @displayedAuthor,
-                                  email              = @email,
+                               email              = @email,
-                                  image_url          = @imageUrl,
+                               image_url          = @imageUrl,
-                                  itunes_category    = @iTunesCategory,
+                               itunes_category    = @iTunesCategory,
-                                  itunes_subcategory = @iTunesSubcategory,
+                               itunes_subcategory = @iTunesSubcategory,
-                                  explicit           = @explicit,
+                               explicit           = @explicit,
-                                  default_media_type = @defaultMediaType,
+                               default_media_type = @defaultMediaType,
-                                  media_base_url     = @mediaBaseUrl,
+                               media_base_url     = @mediaBaseUrl,
-                                  guid               = @guid,
+                               guid               = @guid,
-                                  funding_url        = @fundingUrl,
+                               funding_url        = @fundingUrl,
-                                  funding_text       = @fundingText,
+                               funding_text       = @fundingText,
-                                  medium             = @medium
+                               medium             = @medium
-                            WHERE feed_id = @feedId"""
+                         WHERE feed_id = @feedId"""
                     cmd.Parameters.Clear ()
                     addPodcastParameters cmd it.id podcast
                     do! write cmd
@@ -198,16 +200,14 @@ type SQLiteWebLogData (conn : SqliteConnection) =
     /// Add a web log
     let add webLog = backgroundTask {
         use cmd = conn.CreateCommand ()
-        cmd.CommandText <-
+        cmd.CommandText <- """
-            """INSERT INTO web_log (
+            INSERT INTO web_log (
-                   id, name, subtitle, default_page, posts_per_page, theme_id, url_base, time_zone,
+                id, name, slug, subtitle, default_page, posts_per_page, theme_id, url_base, time_zone, auto_htmx,
-                   auto_htmx, feed_enabled, feed_name, items_in_feed, category_enabled, tag_enabled,
+                uploads, feed_enabled, feed_name, items_in_feed, category_enabled, tag_enabled, copyright
-                   copyright
+            ) VALUES (
-               ) VALUES (
+                @id, @name, @slug, @subtitle, @defaultPage, @postsPerPage, @themeId, @urlBase, @timeZone, @autoHtmx,
-                   @id, @name, @subtitle, @defaultPage, @postsPerPage, @themeId, @urlBase, @timeZone,
+                @uploads, @feedEnabled, @feedName, @itemsInFeed, @categoryEnabled, @tagEnabled, @copyright
-                   @autoHtmx, @feedEnabled, @feedName, @itemsInFeed, @categoryEnabled, @tagEnabled,
+            )"""
-                   @copyright
-               )"""
         addWebLogParameters cmd webLog
         do! write cmd
         do! updateCustomFeeds webLog
@@ -232,25 +232,26 @@ type SQLiteWebLogData (conn : SqliteConnection) =
         let subQuery table = $"(SELECT id FROM {table} WHERE web_log_id = @webLogId)"
         let postSubQuery = subQuery "post"
         let pageSubQuery = subQuery "page"
-        cmd.CommandText <-
+        cmd.CommandText <- $"""
-            $"""DELETE FROM post_comment         WHERE post_id IN {postSubQuery};
+            DELETE FROM post_comment         WHERE post_id IN {postSubQuery};
-                DELETE FROM post_revision        WHERE post_id IN {postSubQuery};
+            DELETE FROM post_revision        WHERE post_id IN {postSubQuery};
-                DELETE FROM post_permalink       WHERE post_id IN {postSubQuery};
+            DELETE FROM post_permalink       WHERE post_id IN {postSubQuery};
-                DELETE FROM post_episode         WHERE post_id IN {postSubQuery};
+            DELETE FROM post_episode         WHERE post_id IN {postSubQuery};
-                DELETE FROM post_tag             WHERE post_id IN {postSubQuery};
+            DELETE FROM post_tag             WHERE post_id IN {postSubQuery};
-                DELETE FROM post_category        WHERE post_id IN {postSubQuery};
+            DELETE FROM post_category        WHERE post_id IN {postSubQuery};
-                DELETE FROM post_meta            WHERE post_id IN {postSubQuery};
+            DELETE FROM post_meta            WHERE post_id IN {postSubQuery};
-                DELETE FROM post                 WHERE web_log_id = @webLogId;
+            DELETE FROM post                 WHERE web_log_id = @webLogId;
-                DELETE FROM page_revision        WHERE page_id IN {pageSubQuery};
+            DELETE FROM page_revision        WHERE page_id IN {pageSubQuery};
-                DELETE FROM page_permalink       WHERE page_id IN {pageSubQuery};
+            DELETE FROM page_permalink       WHERE page_id IN {pageSubQuery};
-                DELETE FROM page_meta            WHERE page_id IN {pageSubQuery};
+            DELETE FROM page_meta            WHERE page_id IN {pageSubQuery};
-                DELETE FROM page                 WHERE web_log_id = @webLogId;
+            DELETE FROM page                 WHERE web_log_id = @webLogId;
-                DELETE FROM category             WHERE web_log_id = @webLogId;
+            DELETE FROM category             WHERE web_log_id = @webLogId;
-                DELETE FROM tag_map              WHERE web_log_id = @webLogId;
+            DELETE FROM tag_map              WHERE web_log_id = @webLogId;
-                DELETE FROM web_log_user         WHERE web_log_id = @webLogId;
+            DELETE FROM upload               WHERE web_log_id = @webLogId;
-                DELETE FROM web_log_feed_podcast WHERE feed_id IN {subQuery "web_log_feed"};
+            DELETE FROM web_log_user         WHERE web_log_id = @webLogId;
-                DELETE FROM web_log_feed         WHERE web_log_id = @webLogId;
+            DELETE FROM web_log_feed_podcast WHERE feed_id IN {subQuery "web_log_feed"};
-                DELETE FROM web_log              WHERE id         = @webLogId"""
+            DELETE FROM web_log_feed         WHERE web_log_id = @webLogId;
+            DELETE FROM web_log              WHERE id         = @webLogId"""
         do! write cmd
     }
     
@@ -283,23 +284,25 @@ type SQLiteWebLogData (conn : SqliteConnection) =
     /// Update settings for a web log
     let updateSettings webLog = backgroundTask {
         use cmd = conn.CreateCommand ()
-        cmd.CommandText <-
+        cmd.CommandText <- """
-            """UPDATE web_log
+            UPDATE web_log
-                  SET name             = @name,
+               SET name             = @name,
-                      subtitle         = @subtitle,
+                   slug             = @slug,
-                      default_page     = @defaultPage,
+                   subtitle         = @subtitle,
-                      posts_per_page   = @postsPerPage,
+                   default_page     = @defaultPage,
-                      theme_id         = @themeId,
+                   posts_per_page   = @postsPerPage,
-                      url_base         = @urlBase,
+                   theme_id         = @themeId,
-                      time_zone        = @timeZone,
+                   url_base         = @urlBase,
-                      auto_htmx        = @autoHtmx,
+                   time_zone        = @timeZone,
-                      feed_enabled     = @feedEnabled,
+                   auto_htmx        = @autoHtmx,
-                      feed_name        = @feedName,
+                   uploads          = @uploads,
-                      items_in_feed    = @itemsInFeed,
+                   feed_enabled     = @feedEnabled,
-                      category_enabled = @categoryEnabled,
+                   feed_name        = @feedName,
-                      tag_enabled      = @tagEnabled,
+                   items_in_feed    = @itemsInFeed,
-                      copyright        = @copyright
+                   category_enabled = @categoryEnabled,
-                WHERE id = @id"""
+                   tag_enabled      = @tagEnabled,
+                   copyright        = @copyright
+             WHERE id = @id"""
         addWebLogParameters cmd webLog
         do! write cmd
     }
@@ -307,15 +310,15 @@ type SQLiteWebLogData (conn : SqliteConnection) =
     /// Update RSS options for a web log
     let updateRssOptions webLog = backgroundTask {
         use cmd = conn.CreateCommand ()
-        cmd.CommandText <-
+        cmd.CommandText <- """
-            """UPDATE web_log
+            UPDATE web_log
-                  SET feed_enabled     = @feedEnabled,
+               SET feed_enabled     = @feedEnabled,
-                      feed_name        = @feedName,
+                   feed_name        = @feedName,
-                      items_in_feed    = @itemsInFeed,
+                   items_in_feed    = @itemsInFeed,
-                      category_enabled = @categoryEnabled,
+                   category_enabled = @categoryEnabled,
-                      tag_enabled      = @tagEnabled,
+                   tag_enabled      = @tagEnabled,
-                      copyright        = @copyright
+                   copyright        = @copyright
-                WHERE id = @id"""
+             WHERE id = @id"""
         addWebLogRssParameters cmd webLog
         do! write cmd
         do! updateCustomFeeds webLog

src/MyWebLog.Data/SQLite/SQLiteWebLogUserData.fs

@@ -28,14 +28,14 @@ type SQLiteWebLogUserData (conn : SqliteConnection) =
     /// Add a user
     let add user = backgroundTask {
         use cmd = conn.CreateCommand ()
-        cmd.CommandText <-
+        cmd.CommandText <- """
-            """INSERT INTO web_log_user (
+            INSERT INTO web_log_user (
-                   id, web_log_id, user_name, first_name, last_name, preferred_name, password_hash, salt,
+                id, web_log_id, user_name, first_name, last_name, preferred_name, password_hash, salt, url,
-                   url, authorization_level
+                authorization_level
-               ) VALUES (
+            ) VALUES (
-                   @id, @webLogId, @userName, @firstName, @lastName, @preferredName, @passwordHash, @salt,
+                @id, @webLogId, @userName, @firstName, @lastName, @preferredName, @passwordHash, @salt, @url,
-                   @url, @authorizationLevel
+                @authorizationLevel
-               )"""
+            )"""
         addWebLogUserParameters cmd user
         do! write cmd
     }
@@ -43,8 +43,7 @@ type SQLiteWebLogUserData (conn : SqliteConnection) =
     /// Find a user by their e-mail address for the given web log
     let findByEmail (email : string) webLogId = backgroundTask {
         use cmd = conn.CreateCommand ()
-        cmd.CommandText <-
+        cmd.CommandText <- "SELECT * FROM web_log_user WHERE web_log_id = @webLogId AND user_name = @userName"
-            "SELECT * FROM web_log_user WHERE web_log_id = @webLogId AND user_name = @userName"
         addWebLogId cmd webLogId
         cmd.Parameters.AddWithValue ("@userName", email) |> ignore
         use! rdr = cmd.ExecuteReaderAsync ()
@@ -95,18 +94,18 @@ type SQLiteWebLogUserData (conn : SqliteConnection) =
     /// Update a user
     let update user = backgroundTask {
         use cmd = conn.CreateCommand ()
-        cmd.CommandText <-
+        cmd.CommandText <- """
-            """UPDATE web_log_user
+            UPDATE web_log_user
-                  SET user_name           = @userName,
+               SET user_name           = @userName,
-                      first_name          = @firstName,
+                   first_name          = @firstName,
-                      last_name           = @lastName,
+                   last_name           = @lastName,
-                      preferred_name      = @preferredName,
+                   preferred_name      = @preferredName,
-                      password_hash       = @passwordHash,
+                   password_hash       = @passwordHash,
-                      salt                = @salt,
+                   salt                = @salt,
-                      url                 = @url,
+                   url                 = @url,
-                      authorization_level = @authorizationLevel
+                   authorization_level = @authorizationLevel
-                WHERE id         = @id
+             WHERE id         = @id
-                  AND web_log_id = @webLogId"""
+               AND web_log_id = @webLogId"""
         addWebLogUserParameters cmd user
         do! write cmd
     }

src/MyWebLog.Data/SQLiteData.fs

@@ -36,6 +36,7 @@ type SQLiteData (conn : SqliteConnection, log : ILogger<SQLiteData>) =
         member _.TagMap     = SQLiteTagMapData     conn
         member _.Theme      = SQLiteThemeData      conn
         member _.ThemeAsset = SQLiteThemeAssetData conn
+        member _.Upload     = SQLiteUploadData     conn
         member _.WebLog     = SQLiteWebLogData     conn
         member _.WebLogUser = SQLiteWebLogUserData conn
         
@@ -48,8 +49,8 @@ type SQLiteData (conn : SqliteConnection, log : ILogger<SQLiteData>) =
             | true -> ()
             | false ->
                 log.LogInformation "Creating theme table..."
-                cmd.CommandText <-
+                cmd.CommandText <- """
-                    """CREATE TABLE theme (
+                    CREATE TABLE theme (
                         id       TEXT PRIMARY KEY,
                         name     TEXT NOT NULL,
                         version  TEXT NOT NULL)"""
@@ -58,8 +59,8 @@ type SQLiteData (conn : SqliteConnection, log : ILogger<SQLiteData>) =
             | true -> ()
             | false ->
                 log.LogInformation "Creating theme_template table..."
-                cmd.CommandText <-
+                cmd.CommandText <- """
-                    """CREATE TABLE theme_template (
+                    CREATE TABLE theme_template (
                         theme_id  TEXT NOT NULL REFERENCES theme (id),
                         name      TEXT NOT NULL,
                         template  TEXT NOT NULL,
@@ -69,8 +70,8 @@ type SQLiteData (conn : SqliteConnection, log : ILogger<SQLiteData>) =
             | true -> ()
             | false ->
                 log.LogInformation "Creating theme_asset table..."
-                cmd.CommandText <-
+                cmd.CommandText <- """
-                    """CREATE TABLE theme_asset (
+                    CREATE TABLE theme_asset (
                         theme_id    TEXT NOT NULL REFERENCES theme (id),
                         path        TEXT NOT NULL,
                         updated_on  TEXT NOT NULL,
@@ -83,10 +84,11 @@ type SQLiteData (conn : SqliteConnection, log : ILogger<SQLiteData>) =
             | true -> ()
             | false ->
                 log.LogInformation "Creating web_log table..."
-                cmd.CommandText <-
+                cmd.CommandText <- """
-                    """CREATE TABLE web_log (
+                    CREATE TABLE web_log (
                         id                TEXT PRIMARY KEY,
                         name              TEXT NOT NULL,
+                        slug              TEXT NOT NULL,
                         subtitle          TEXT,
                         default_page      TEXT NOT NULL,
                         posts_per_page    INTEGER NOT NULL,
@@ -94,30 +96,33 @@ type SQLiteData (conn : SqliteConnection, log : ILogger<SQLiteData>) =
                         url_base          TEXT NOT NULL,
                         time_zone         TEXT NOT NULL,
                         auto_htmx         INTEGER NOT NULL DEFAULT 0,
+                        uploads           TEXT NOT NULL,
                         feed_enabled      INTEGER NOT NULL DEFAULT 0,
                         feed_name         TEXT NOT NULL,
                         items_in_feed     INTEGER,
                         category_enabled  INTEGER NOT NULL DEFAULT 0,
                         tag_enabled       INTEGER NOT NULL DEFAULT 0,
-                        copyright         TEXT)"""
+                        copyright         TEXT);
+                    CREATE INDEX web_log_theme_idx ON web_log (theme_id)"""
                 do! write cmd
             match! tableExists "web_log_feed" with
             | true -> ()
             | false ->
                 log.LogInformation "Creating web_log_feed table..."
-                cmd.CommandText <-
+                cmd.CommandText <- """
-                    """CREATE TABLE web_log_feed (
+                    CREATE TABLE web_log_feed (
                         id          TEXT PRIMARY KEY,
                         web_log_id  TEXT NOT NULL REFERENCES web_log (id),
                         source      TEXT NOT NULL,
-                        path        TEXT NOT NULL)"""
+                        path        TEXT NOT NULL);
+                    CREATE INDEX web_log_feed_web_log_idx ON web_log_feed (web_log_id)"""
                 do! write cmd
             match! tableExists "web_log_feed_podcast" with
             | true -> ()
             | false ->
                 log.LogInformation "Creating web_log_feed_podcast table..."
-                cmd.CommandText <-
+                cmd.CommandText <- """
-                    """CREATE TABLE web_log_feed_podcast (
+                    CREATE TABLE web_log_feed_podcast (
                         feed_id             TEXT PRIMARY KEY REFERENCES web_log_feed (id),
                         title               TEXT NOT NULL,
                         subtitle            TEXT,
@@ -142,14 +147,15 @@ type SQLiteData (conn : SqliteConnection, log : ILogger<SQLiteData>) =
             | true -> ()
             | false ->
                 log.LogInformation "Creating category table..."
-                cmd.CommandText <-
+                cmd.CommandText <- """
-                    """CREATE TABLE category (
+                    CREATE TABLE category (
                         id          TEXT PRIMARY KEY,
                         web_log_id  TEXT NOT NULL REFERENCES web_log (id),
                         name        TEXT NOT NULL,
                         slug        TEXT NOT NULL,
                         description TEXT,
-                        parent_id   TEXT)"""
+                        parent_id   TEXT);
+                    CREATE INDEX category_web_log_idx ON category (web_log_id)"""
                 do! write cmd
             
             // Web log user table
@@ -157,8 +163,8 @@ type SQLiteData (conn : SqliteConnection, log : ILogger<SQLiteData>) =
             | true -> ()
             | false ->
                 log.LogInformation "Creating web_log_user table..."
-                cmd.CommandText <-
+                cmd.CommandText <- """
-                    """CREATE TABLE web_log_user (
+                    CREATE TABLE web_log_user (
                         id                   TEXT PRIMARY KEY,
                         web_log_id           TEXT NOT NULL REFERENCES web_log (id),
                         user_name            TEXT NOT NULL,
@@ -168,7 +174,9 @@ type SQLiteData (conn : SqliteConnection, log : ILogger<SQLiteData>) =
                         password_hash        TEXT NOT NULL,
                         salt                 TEXT NOT NULL,
                         url                  TEXT,
-                        authorization_level  TEXT NOT NULL)"""
+                        authorization_level  TEXT NOT NULL);
+                    CREATE INDEX web_log_user_web_log_idx   ON web_log_user (web_log_id);
+                    CREATE INDEX web_log_user_user_name_idx ON web_log_user (web_log_id, user_name)"""
                 do! write cmd
             
             // Page tables
@@ -176,8 +184,8 @@ type SQLiteData (conn : SqliteConnection, log : ILogger<SQLiteData>) =
             | true -> ()
             | false ->
                 log.LogInformation "Creating page table..."
-                cmd.CommandText <-
+                cmd.CommandText <- """
-                    """CREATE TABLE page (
+                    CREATE TABLE page (
                         id                 TEXT PRIMARY KEY,
                         web_log_id         TEXT NOT NULL REFERENCES web_log (id),
                         author_id          TEXT NOT NULL REFERENCES web_log_user (id),
@@ -187,14 +195,17 @@ type SQLiteData (conn : SqliteConnection, log : ILogger<SQLiteData>) =
                         updated_on         TEXT NOT NULL,
                         show_in_page_list  INTEGER NOT NULL DEFAULT 0,
                         template           TEXT,
-                        page_text          TEXT NOT NULL)"""
+                        page_text          TEXT NOT NULL);
+                    CREATE INDEX page_web_log_idx   ON page (web_log_id);
+                    CREATE INDEX page_author_idx    ON page (author_id);
+                    CREATE INDEX page_permalink_idx ON page (web_log_id, permalink)"""
                 do! write cmd
             match! tableExists "page_meta" with
             | true -> ()
             | false ->
                 log.LogInformation "Creating page_meta table..."
-                cmd.CommandText <-
+                cmd.CommandText <- """
-                    """CREATE TABLE page_meta (
+                    CREATE TABLE page_meta (
                         page_id  TEXT NOT NULL REFERENCES page (id),
                         name     TEXT NOT NULL,
                         value    TEXT NOT NULL,
@@ -204,8 +215,8 @@ type SQLiteData (conn : SqliteConnection, log : ILogger<SQLiteData>) =
             | true -> ()
             | false ->
                 log.LogInformation "Creating page_permalink table..."
-                cmd.CommandText <-
+                cmd.CommandText <- """
-                    """CREATE TABLE page_permalink (
+                    CREATE TABLE page_permalink (
                         page_id    TEXT NOT NULL REFERENCES page (id),
                         permalink  TEXT NOT NULL,
                         PRIMARY KEY (page_id, permalink))"""
@@ -214,8 +225,8 @@ type SQLiteData (conn : SqliteConnection, log : ILogger<SQLiteData>) =
             | true -> ()
             | false ->
                 log.LogInformation "Creating page_revision table..."
-                cmd.CommandText <-
+                cmd.CommandText <- """
-                    """CREATE TABLE page_revision (
+                    CREATE TABLE page_revision (
                         page_id        TEXT NOT NULL REFERENCES page (id),
                         as_of          TEXT NOT NULL,
                         revision_text  TEXT NOT NULL,
@@ -227,8 +238,8 @@ type SQLiteData (conn : SqliteConnection, log : ILogger<SQLiteData>) =
             | true -> ()
             | false ->
                 log.LogInformation "Creating post table..."
-                cmd.CommandText <-
+                cmd.CommandText <- """
-                    """CREATE TABLE post (
+                    CREATE TABLE post (
                         id            TEXT PRIMARY KEY,
                         web_log_id    TEXT NOT NULL REFERENCES web_log (id),
                         author_id     TEXT NOT NULL REFERENCES web_log_user (id),
@@ -238,24 +249,29 @@ type SQLiteData (conn : SqliteConnection, log : ILogger<SQLiteData>) =
                         published_on  TEXT,
                         updated_on    TEXT NOT NULL,
                         template      TEXT,
-                        post_text     TEXT NOT NULL)"""
+                        post_text     TEXT NOT NULL);
+                    CREATE INDEX post_web_log_idx   ON post (web_log_id);
+                    CREATE INDEX post_author_idx    ON post (author_id);
+                    CREATE INDEX post_status_idx    ON post (web_log_id, status, updated_on);
+                    CREATE INDEX post_permalink_idx ON post (web_log_id, permalink)"""
                 do! write cmd
             match! tableExists "post_category" with
             | true -> ()
             | false ->
                 log.LogInformation "Creating post_category table..."
-                cmd.CommandText <-
+                cmd.CommandText <- """
-                    """CREATE TABLE post_category (
+                    CREATE TABLE post_category (
                         post_id      TEXT NOT NULL REFERENCES post (id),
                         category_id  TEXT NOT NULL REFERENCES category (id),
-                        PRIMARY KEY (post_id, category_id))"""
+                        PRIMARY KEY (post_id, category_id));
+                    CREATE INDEX post_category_category_idx ON post_category (category_id)"""
                 do! write cmd
             match! tableExists "post_episode" with
             | true -> ()
             | false ->
                 log.LogInformation "Creating post_episode table..."
-                cmd.CommandText <-
+                cmd.CommandText <- """
-                    """CREATE TABLE post_episode (
+                    CREATE TABLE post_episode (
                         post_id              TEXT PRIMARY KEY REFERENCES post(id),
                         media                TEXT NOT NULL,
                         length               INTEGER NOT NULL,
@@ -279,8 +295,8 @@ type SQLiteData (conn : SqliteConnection, log : ILogger<SQLiteData>) =
             | true -> ()
             | false ->
                 log.LogInformation "Creating post_tag table..."
-                cmd.CommandText <-
+                cmd.CommandText <- """
-                    """CREATE TABLE post_tag (
+                    CREATE TABLE post_tag (
                         post_id  TEXT NOT NULL REFERENCES post (id),
                         tag      TEXT NOT NULL,
                         PRIMARY KEY (post_id, tag))"""
@@ -289,8 +305,8 @@ type SQLiteData (conn : SqliteConnection, log : ILogger<SQLiteData>) =
             | true -> ()
             | false ->
                 log.LogInformation "Creating post_meta table..."
-                cmd.CommandText <-
+                cmd.CommandText <- """
-                    """CREATE TABLE post_meta (
+                    CREATE TABLE post_meta (
                         post_id  TEXT NOT NULL REFERENCES post (id),
                         name     TEXT NOT NULL,
                         value    TEXT NOT NULL,
@@ -300,8 +316,8 @@ type SQLiteData (conn : SqliteConnection, log : ILogger<SQLiteData>) =
             | true -> ()
             | false ->
                 log.LogInformation "Creating post_permalink table..."
-                cmd.CommandText <-
+                cmd.CommandText <- """
-                    """CREATE TABLE post_permalink (
+                    CREATE TABLE post_permalink (
                         post_id    TEXT NOT NULL REFERENCES post (id),
                         permalink  TEXT NOT NULL,
                         PRIMARY KEY (post_id, permalink))"""
@@ -310,8 +326,8 @@ type SQLiteData (conn : SqliteConnection, log : ILogger<SQLiteData>) =
             | true -> ()
             | false ->
                 log.LogInformation "Creating post_revision table..."
-                cmd.CommandText <-
+                cmd.CommandText <- """
-                    """CREATE TABLE post_revision (
+                    CREATE TABLE post_revision (
                         post_id        TEXT NOT NULL REFERENCES post (id),
                         as_of          TEXT NOT NULL,
                         revision_text  TEXT NOT NULL,
@@ -321,8 +337,8 @@ type SQLiteData (conn : SqliteConnection, log : ILogger<SQLiteData>) =
             | true -> ()
             | false ->
                 log.LogInformation "Creating post_comment table..."
-                cmd.CommandText <-
+                cmd.CommandText <- """
-                    """CREATE TABLE post_comment (
+                    CREATE TABLE post_comment (
                         id              TEXT PRIMARY KEY,
                         post_id         TEXT NOT NULL REFERENCES post(id),
                         in_reply_to_id  TEXT,
@@ -331,7 +347,8 @@ type SQLiteData (conn : SqliteConnection, log : ILogger<SQLiteData>) =
                         url             TEXT,
                         status          TEXT NOT NULL,
                         posted_on       TEXT NOT NULL,
-                        comment_text    TEXT NOT NULL)"""
+                        comment_text    TEXT NOT NULL);
+                    CREATE INDEX post_comment_post_idx ON post_comment (post_id)"""
                 do! write cmd
             
             // Tag map table
@@ -339,11 +356,28 @@ type SQLiteData (conn : SqliteConnection, log : ILogger<SQLiteData>) =
             | true -> ()
             | false ->
                 log.LogInformation "Creating tag_map table..."
-                cmd.CommandText <-
+                cmd.CommandText <- """
-                    """CREATE TABLE tag_map (
+                    CREATE TABLE tag_map (
                         id          TEXT PRIMARY KEY,
                         web_log_id  TEXT NOT NULL REFERENCES web_log (id),
                         tag         TEXT NOT NULL,
-                        url_value   TEXT NOT NULL)"""
+                        url_value   TEXT NOT NULL);
+                    CREATE INDEX tag_map_web_log_idx ON tag_map (web_log_id)"""
+                do! write cmd
+            
+            // Uploaded file table
+            match! tableExists "upload" with
+            | true -> ()
+            | false ->
+                log.LogInformation "Creating upload table..."
+                cmd.CommandText <- """
+                    CREATE TABLE upload (
+                        id          TEXT PRIMARY KEY,
+                        web_log_id  TEXT NOT NULL REFERENCES web_log (id),
+                        path        TEXT NOT NULL,
+                        updated_on  TEXT NOT NULL,
+                        data        BLOB NOT NULL);
+                    CREATE INDEX upload_web_log_idx ON upload (web_log_id);
+                    CREATE INDEX upload_path_idx    ON upload (web_log_id, path)"""
                 do! write cmd
         }

src/MyWebLog.Domain/DataTypes.fs

@@ -295,6 +295,37 @@ type ThemeAsset =
     }
 
 
+/// An uploaded file
+type Upload =
+    {   /// The ID of the upload
+        id : UploadId
+        
+        /// The ID of the web log to which this upload belongs
+        webLogId : WebLogId
+        
+        /// The link at which this upload is served
+        path : Permalink
+        
+        /// The updated date/time for this upload
+        updatedOn : DateTime
+        
+        /// The data for the upload
+        data : byte[]
+    }
+
+/// Functions to support uploaded files
+module Upload =
+    
+    /// An empty upload
+    let empty = {
+        id        = UploadId.empty
+        webLogId  = WebLogId.empty
+        path      = Permalink.empty
+        updatedOn = DateTime.MinValue
+        data      = [||]
+    }
+
+
 /// A web log
 [<CLIMutable; NoComparison; NoEquality>]
 type WebLog =
@@ -304,6 +335,9 @@ type WebLog =
         /// The name of the web log
         name : string
 
+        /// The slug of the web log
+        slug : string
+        
         /// A subtitle for the web log
         subtitle : string option
 
@@ -327,6 +361,9 @@ type WebLog =
         
         /// Whether to automatically load htmx
         autoHtmx : bool
+        
+        /// Where uploads are placed
+        uploads : UploadDestination
     }
 
 /// Functions to support web logs
@@ -336,6 +373,7 @@ module WebLog =
     let empty =
         { id           = WebLogId.empty
           name         = ""
+          slug         = ""
           subtitle     = None
           defaultPage  = ""
           postsPerPage = 10
@@ -344,6 +382,7 @@ module WebLog =
           timeZone     = ""
           rss          = RssOptions.empty
           autoHtmx     = false
+          uploads      = Database
         }
     
     /// Get the host (including scheme) and extra path from the URL base

src/MyWebLog.Domain/SupportTypes.fs

@@ -556,6 +556,41 @@ type ThemeTemplate =
     }
 
 
+/// Where uploads should be placed
+type UploadDestination =
+    | Database
+    | Disk
+
+/// Functions to support upload destinations
+module UploadDestination =
+    
+    /// Convert an upload destination to its string representation
+    let toString = function Database -> "database" | Disk -> "disk"
+    
+    /// Parse an upload destination from its string representation
+    let parse value =
+        match value with
+        | "database" -> Database
+        | "disk"     -> Disk
+        | it         -> invalidOp $"{it} is not a valid upload destination"
+
+
+/// An identifier for an upload
+type UploadId = UploadId of string
+
+/// Functions to support upload IDs
+module UploadId =
+    
+    /// An empty upload ID
+    let empty = UploadId ""
+    
+    /// Convert an upload ID to a string
+    let toString = function UploadId ui -> ui
+    
+    /// Create a new upload ID
+    let create () = UploadId (newId ())
+
+
 /// An identifier for a web log
 type WebLogId = WebLogId of string
 

src/MyWebLog.Domain/ViewModels.fs

@@ -12,6 +12,29 @@ module private Helpers =
         match (defaultArg (Option.ofObj it) "").Trim () with "" -> None | trimmed -> Some trimmed
 
 
+/// The model used to display the admin dashboard
+[<NoComparison; NoEquality>]
+type DashboardModel =
+    {   /// The number of published posts
+        posts : int
+
+        /// The number of post drafts
+        drafts : int
+
+        /// The number of pages
+        pages : int
+
+        /// The number of pages in the page list
+        listedPages : int
+
+        /// The number of categories
+        categories : int
+
+        /// The top-level categories
+        topLevelCategories : int
+    }
+
+
 /// Details about a category, used to display category lists
 [<NoComparison; NoEquality>]
 type DisplayCategory =
@@ -124,27 +147,37 @@ type DisplayPage =
         }
 
 
-/// The model used to display the admin dashboard
+open System.IO
+
+/// Information about an uploaded file used for display
 [<NoComparison; NoEquality>]
-type DashboardModel =
+type DisplayUpload =
-    {   /// The number of published posts
+    {   /// The ID of the uploaded file
-        posts : int
+        id : string
-
+        
-        /// The number of post drafts
+        /// The name of the uploaded file
-        drafts : int
+        name : string
-
+        
-        /// The number of pages
+        /// The path at which the file is served
-        pages : int
+        path : string
-
+        
-        /// The number of pages in the page list
+        /// The date/time the file was updated
-        listedPages : int
+        updatedOn : DateTime option
-
+        
-        /// The number of categories
+        /// The source for this file (created from UploadDestination DU)
-        categories : int
+        source : string
-
-        /// The top-level categories
-        topLevelCategories : int
     }
+    
+    /// Create a display uploaded file
+    static member fromUpload webLog source (upload : Upload) =
+        let path = Permalink.toString upload.path
+        let name = Path.GetFileName path
+        { id        = UploadId.toString upload.id
+          name      = name
+          path      = path.Replace (name, "")
+          updatedOn = Some (WebLog.localTime webLog upload.updatedOn)
+          source    = UploadDestination.toString source
+        }
 
 
 /// View model for editing categories
@@ -229,6 +262,18 @@ type EditCustomFeedModel =
         
         /// The base URL for relative URL media files for this podcast (optional; defaults to web log base)
         mediaBaseUrl : string
+        
+        /// The URL for funding information for the podcast
+        fundingUrl : string
+        
+        /// The text for the funding link
+        fundingText : string
+        
+        /// A unique identifier to follow this podcast
+        guid : string
+        
+        /// The medium for the content of this podcast
+        medium : string
     }
     
     /// An empty custom feed model
@@ -250,6 +295,10 @@ type EditCustomFeedModel =
           explicit          = "no"
           defaultMediaType  = "audio/mpeg"
           mediaBaseUrl      = ""
+          fundingUrl        = ""
+          fundingText       = ""
+          guid              = ""
+          medium            = ""
         }
     
     /// Create a model from a custom feed
@@ -277,6 +326,12 @@ type EditCustomFeedModel =
                 explicit          = ExplicitRating.toString p.explicit
                 defaultMediaType  = defaultArg p.defaultMediaType ""
                 mediaBaseUrl      = defaultArg p.mediaBaseUrl ""
+                fundingUrl        = defaultArg p.fundingUrl ""
+                fundingText       = defaultArg p.fundingText ""
+                guid              = p.guid
+                                    |> Option.map (fun it -> it.ToString().ToLowerInvariant ())
+                                    |> Option.defaultValue ""
+                medium            = p.medium |> Option.map PodcastMedium.toString |> Option.defaultValue ""
             }
         | None -> rss
     
@@ -300,11 +355,10 @@ type EditCustomFeedModel =
                         explicit          = ExplicitRating.parse this.explicit
                         defaultMediaType  = noneIfBlank this.defaultMediaType
                         mediaBaseUrl      = noneIfBlank this.mediaBaseUrl
-                        // TODO: implement UI to update these
+                        guid              = noneIfBlank this.guid |> Option.map Guid.Parse
-                        guid              = None
+                        fundingUrl        = noneIfBlank this.fundingUrl
-                        fundingUrl        = None
+                        fundingText       = noneIfBlank this.fundingText
-                        fundingText       = None
+                        medium            = noneIfBlank this.medium |> Option.map PodcastMedium.parse
-                        medium            = None
                     }
                 else
                     None
@@ -802,6 +856,9 @@ type SettingsModel =
     {   /// The name of the web log
         name : string
 
+        /// The slug of the web log
+        slug : string
+        
         /// The subtitle of the web log
         subtitle : string
 
@@ -819,32 +876,48 @@ type SettingsModel =
         
         /// Whether to automatically load htmx
         autoHtmx : bool
+        
+        /// The default location for uploads
+        uploads : string
     }
     
     /// Create a settings model from a web log
     static member fromWebLog (webLog : WebLog) =
         { name         = webLog.name
+          slug         = webLog.slug
           subtitle     = defaultArg webLog.subtitle ""
           defaultPage  = webLog.defaultPage
           postsPerPage = webLog.postsPerPage
           timeZone     = webLog.timeZone
           themePath    = webLog.themePath
           autoHtmx     = webLog.autoHtmx
+          uploads      = UploadDestination.toString webLog.uploads
         }
     
     /// Update a web log with settings from the form
     member this.update (webLog : WebLog) =
         { webLog with
             name         = this.name
+            slug         = this.slug
             subtitle     = if this.subtitle = "" then None else Some this.subtitle
             defaultPage  = this.defaultPage
             postsPerPage = this.postsPerPage
             timeZone     = this.timeZone
             themePath    = this.themePath
             autoHtmx     = this.autoHtmx
+            uploads      = UploadDestination.parse this.uploads
         }
 
 
+/// View model for uploading a file
+[<CLIMutable; NoComparison; NoEquality>]
+type UploadFileModel =
+    {   /// The upload destination
+        destination : string
+    }
+
+
+/// A message displayed to the user
 [<CLIMutable; NoComparison; NoEquality>]
 type UserMessage =
     {   /// The level of the message

src/MyWebLog/DotLiquidBespoke.fs

@@ -223,16 +223,16 @@ let register () =
     Template.RegisterTag<UserLinksTag> "user_links"
     
     [   // Domain types
-        typeof<CustomFeed>; typeof<Episode>; typeof<Episode option>; typeof<MetaItem>; typeof<Page>; typeof<RssOptions>
+        typeof<CustomFeed>; typeof<Episode>; typeof<Episode option>;    typeof<MetaItem>; typeof<Page>
-        typeof<TagMap>;     typeof<WebLog>
+        typeof<RssOptions>; typeof<TagMap>;  typeof<UploadDestination>; typeof<WebLog>
         // View models
-        typeof<DashboardModel>;        typeof<DisplayCategory>;     typeof<DisplayCustomFeed>; typeof<DisplayPage>
+        typeof<DashboardModel>; typeof<DisplayCategory>;       typeof<DisplayCustomFeed>;   typeof<DisplayPage>
-        typeof<EditCategoryModel>;     typeof<EditCustomFeedModel>; typeof<EditPageModel>;     typeof<EditPostModel>
+        typeof<DisplayUpload>;  typeof<EditCategoryModel>;     typeof<EditCustomFeedModel>; typeof<EditPageModel>
-        typeof<EditRssModel>;          typeof<EditTagMapModel>;     typeof<EditUserModel>;     typeof<LogOnModel>
+        typeof<EditPostModel>;  typeof<EditRssModel>;          typeof<EditTagMapModel>;     typeof<EditUserModel>
-        typeof<ManagePermalinksModel>; typeof<PostDisplay>;         typeof<PostListItem>;      typeof<SettingsModel>
+        typeof<LogOnModel>;     typeof<ManagePermalinksModel>; typeof<PostDisplay>;         typeof<PostListItem>
-        typeof<UserMessage>
+        typeof<SettingsModel>;  typeof<UserMessage>
         // Framework types
-        typeof<AntiforgeryTokenSet>; typeof<int option>;    typeof<KeyValuePair>; typeof<MetaItem list>
+        typeof<AntiforgeryTokenSet>; typeof<DateTime option>; typeof<int option>;    typeof<KeyValuePair>
-        typeof<string list>;         typeof<string option>; typeof<TagMap list>
+        typeof<MetaItem list>;       typeof<string list>;     typeof<string option>; typeof<TagMap list>
     ]
     |> List.iter (fun it -> Template.RegisterSafeType (it, [| "*" |]))

src/MyWebLog/Handlers/Admin.fs

@@ -475,11 +475,15 @@ let settings : HttpHandler = fun next ctx -> task {
                            |> List.map (fun p -> KeyValuePair.Create (PageId.toString p.id, p.title))
                 }
                 |> Array.ofSeq
-            themes     = themes
+            themes =
-                         |> Seq.ofList
+                themes
-                         |> Seq.map (fun it ->
+                 |> Seq.ofList
-                             KeyValuePair.Create (ThemeId.toString it.id, $"{it.name} (v{it.version})"))
+                 |> Seq.map (fun it -> KeyValuePair.Create (ThemeId.toString it.id, $"{it.name} (v{it.version})"))
-                         |> Array.ofSeq
+                 |> Array.ofSeq
+            upload_values =
+                [|  KeyValuePair.Create (UploadDestination.toString Database, "Database")
+                    KeyValuePair.Create (UploadDestination.toString Disk,     "Disk")
+                |]
             web_log    = webLog
             page_title = "Web Log Settings"
         |}
@@ -493,11 +497,18 @@ let saveSettings : HttpHandler = fun next ctx -> task {
     let! model  = ctx.BindFormAsync<SettingsModel> ()
     match! data.WebLog.findById webLog.id with
     | Some webLog ->
-        let webLog = model.update webLog
+        let oldSlug = webLog.slug
+        let webLog  = model.update webLog
         do! data.WebLog.updateSettings webLog
 
         // Update cache
         WebLogCache.set webLog
+        
+        if oldSlug <> webLog.slug then
+            // Rename disk directory if it exists
+            let uploadRoot = Path.Combine ("wwwroot", "upload")
+            let oldDir     = Path.Combine (uploadRoot, oldSlug)
+            if Directory.Exists oldDir then Directory.Move (oldDir, Path.Combine (uploadRoot, webLog.slug))
     
         do! addMessage ctx { UserMessage.success with message = "Web log settings saved successfully" }
         return! redirectToGet (WebLog.relativeUrl webLog (Permalink "admin/settings")) next ctx

src/MyWebLog/Handlers/Feed.fs

@@ -2,6 +2,7 @@
 module MyWebLog.Handlers.Feed
 
 open System
+open System.Collections.Generic
 open System.IO
 open System.Net
 open System.ServiceModel.Syndication
@@ -129,17 +130,19 @@ let private toFeedItem webLog (authors : MetaItem list) (cats : DisplayCategory[
     |> List.iter item.Categories.Add
     item
 
+/// Convert non-absolute URLs to an absolute URL for this web log
+let toAbsolute webLog (link : string) =
+    if link.StartsWith "http" then link else WebLog.absoluteUrl webLog (Permalink link)
+
 /// Add episode information to a podcast feed item
 let private addEpisode webLog (podcast : PodcastOptions) (episode : Episode) (post : Post) (item : SyndicationItem) =
-    // Convert non-absolute URLs to an absolute URL for this web log
-    let toAbsolute (link : string) = if link.StartsWith "http" then link else WebLog.absoluteUrl webLog (Permalink link)
     let epMediaUrl =
         match episode.media with
         | link when link.StartsWith "http" -> link
         | link when Option.isSome podcast.mediaBaseUrl -> $"{podcast.mediaBaseUrl.Value}{link}"
         | link -> WebLog.absoluteUrl webLog (Permalink link)
     let epMediaType = [ episode.mediaType; podcast.defaultMediaType ] |> List.tryFind Option.isSome |> Option.flatten
-    let epImageUrl = defaultArg episode.imageUrl (Permalink.toString podcast.imageUrl) |> toAbsolute
+    let epImageUrl = defaultArg episode.imageUrl (Permalink.toString podcast.imageUrl) |> toAbsolute webLog
     let epExplicit = defaultArg episode.explicit podcast.explicit |> ExplicitRating.toString
     
     let xmlDoc    = XmlDocument ()
@@ -165,7 +168,7 @@ let private addEpisode webLog (podcast : PodcastOptions) (episode : Episode) (po
     
     match episode.chapterFile with
     | Some chapters ->
-        let url = toAbsolute chapters
+        let url = toAbsolute webLog chapters
         let typ =
             match episode.chapterType with
             | Some mime -> Some mime
@@ -179,7 +182,7 @@ let private addEpisode webLog (podcast : PodcastOptions) (episode : Episode) (po
     
     match episode.transcriptUrl with
     | Some transcript ->
-        let url = toAbsolute transcript
+        let url = toAbsolute webLog transcript
         let elt = xmlDoc.CreateElement ("podcast", "transcript", Namespace.podcast)
         elt.SetAttribute ("url", url)
         elt.SetAttribute ("type", Option.get episode.transcriptType)
@@ -301,6 +304,17 @@ let private addPodcast webLog (rssFeed : SyndicationFeed) (feed : CustomFeed) =
     rssFeed.ElementExtensions.Add ("author",    Namespace.iTunes,   podcast.displayedAuthor)
     rssFeed.ElementExtensions.Add ("explicit",  Namespace.iTunes,   ExplicitRating.toString podcast.explicit)
     podcast.subtitle |> Option.iter (fun sub -> rssFeed.ElementExtensions.Add ("subtitle", Namespace.iTunes, sub))
+    podcast.fundingUrl
+    |> Option.iter (fun url ->
+        let funding = xmlDoc.CreateElement ("podcast", "funding", Namespace.podcast)
+        funding.SetAttribute ("url", toAbsolute webLog url)
+        funding.InnerText <- defaultArg podcast.fundingText "Support This Podcast"
+        rssFeed.ElementExtensions.Add funding)
+    podcast.guid
+    |> Option.iter (fun guid ->
+        rssFeed.ElementExtensions.Add ("guid", Namespace.podcast, guid.ToString().ToLowerInvariant ()))
+    podcast.medium
+    |> Option.iter (fun med -> rssFeed.ElementExtensions.Add ("medium", Namespace.podcast, PodcastMedium.toString med))
 
 /// Get the feed's self reference and non-feed link
 let private selfAndLink webLog feedType ctx =
@@ -402,7 +416,7 @@ let generate (feedType : FeedType) postCount : HttpHandler = fun next ctx -> bac
 
 open DotLiquid
 
-// GET: /admin/rss/settings
+// GET: /admin/settings/rss
 let editSettings : HttpHandler = fun next ctx -> task {
     let webLog = ctx.WebLog
     let feeds =
@@ -418,7 +432,7 @@ let editSettings : HttpHandler = fun next ctx -> task {
         |> viewForTheme "admin" "rss-settings" next ctx
 }
 
-// POST: /admin/rss/settings
+// POST: /admin/settings/rss
 let saveSettings : HttpHandler = fun next ctx -> task {
     let  data  = ctx.Data
     let! model = ctx.BindFormAsync<EditRssModel> ()
@@ -432,7 +446,7 @@ let saveSettings : HttpHandler = fun next ctx -> task {
     | None -> return! Error.notFound next ctx
 }
 
-// GET: /admin/rss/{id}/edit
+// GET: /admin/settings/rss/{id}/edit
 let editCustomFeed feedId : HttpHandler = fun next ctx -> task {
     let customFeed =
         match feedId with
@@ -441,16 +455,26 @@ let editCustomFeed feedId : HttpHandler = fun next ctx -> task {
     match customFeed with
     | Some f ->
         return! Hash.FromAnonymousObject
-            {|  csrf       = csrfToken ctx
+            {|  csrf          = csrfToken ctx
-                page_title = $"""{if feedId = "new" then "Add" else "Edit"} Custom RSS Feed"""
+                page_title    = $"""{if feedId = "new" then "Add" else "Edit"} Custom RSS Feed"""
-                model      = EditCustomFeedModel.fromFeed f
+                model         = EditCustomFeedModel.fromFeed f
-                categories = CategoryCache.get ctx
+                categories    = CategoryCache.get ctx
+                medium_values = [|
+                    KeyValuePair.Create ("", "&ndash; Unspecified &ndash;")
+                    KeyValuePair.Create (PodcastMedium.toString Podcast, "Podcast")
+                    KeyValuePair.Create (PodcastMedium.toString Music, "Music")
+                    KeyValuePair.Create (PodcastMedium.toString Video, "Video")
+                    KeyValuePair.Create (PodcastMedium.toString Film, "Film")
+                    KeyValuePair.Create (PodcastMedium.toString Audiobook, "Audiobook")
+                    KeyValuePair.Create (PodcastMedium.toString Newsletter, "Newsletter")
+                    KeyValuePair.Create (PodcastMedium.toString Blog, "Blog")
+                |]
             |}
             |> viewForTheme "admin" "custom-feed-edit" next ctx
     | None -> return! Error.notFound next ctx
 }
 
-// POST: /admin/rss/save
+// POST: /admin/settings/rss/save
 let saveCustomFeed : HttpHandler = fun next ctx -> task {
     let data = ctx.Data
     match! data.WebLog.findById ctx.WebLog.id with
@@ -476,7 +500,7 @@ let saveCustomFeed : HttpHandler = fun next ctx -> task {
     | None -> return! Error.notFound next ctx
 }
 
-// POST /admin/rss/{id}/delete
+// POST /admin/settings/rss/{id}/delete
 let deleteCustomFeed feedId : HttpHandler = fun next ctx -> task {
     let data = ctx.Data
     match! data.WebLog.findById ctx.WebLog.id with

src/MyWebLog/Handlers/Routes.fs

@@ -93,55 +93,25 @@ module CatchAll =
 /// Serve theme assets
 module Asset =
     
-    open System
-    open Microsoft.AspNetCore.Http.Headers
-    open Microsoft.AspNetCore.StaticFiles
-    open Microsoft.Net.Http.Headers
-    
-    /// Determine if the asset has been modified since the date/time specified by the If-Modified-Since header
-    let private checkModified asset (ctx : HttpContext) : HttpHandler option =
-        match ctx.Request.Headers.IfModifiedSince with
-        | it when it.Count < 1 -> None
-        | it ->
-            if asset.updatedOn > DateTime.Parse it[0] then
-                None
-            else
-                Some (setStatusCode 304 >=> setBodyFromString "Not Modified")
-    
-    /// An instance of ASP.NET Core's file extension to MIME type converter
-    let private mimeMap = FileExtensionContentTypeProvider ()
-    
     // GET /theme/{theme}/{**path}
-    let serveAsset (urlParts : string seq) : HttpHandler = fun next ctx -> task {
+    let serve (urlParts : string seq) : HttpHandler = fun next ctx -> task {
         let path = urlParts |> Seq.skip 1 |> Seq.head
         match! ctx.Data.ThemeAsset.findById (ThemeAssetId.ofString path) with
         | Some asset ->
-            match checkModified asset ctx with
+            match Upload.checkModified asset.updatedOn ctx with
             | Some threeOhFour -> return! threeOhFour next ctx
-            | None ->
+            | None -> return! Upload.sendFile asset.updatedOn path asset.data next ctx
-                let mimeType =
-                    match mimeMap.TryGetContentType path with
-                    | true,  typ -> typ
-                    | false, _   -> "application/octet-stream"
-                let headers = ResponseHeaders ctx.Response.Headers
-                headers.LastModified <- Some (DateTimeOffset asset.updatedOn) |> Option.toNullable
-                headers.ContentType  <- MediaTypeHeaderValue mimeType
-                headers.CacheControl <-
-                    let hdr = CacheControlHeaderValue()
-                    hdr.MaxAge <- Some (TimeSpan.FromDays 30) |> Option.toNullable
-                    hdr
-                return! setBody asset.data next ctx
         | None -> return! Error.notFound next ctx
     }
 
 
 /// The primary myWebLog router
 let router : HttpHandler = choose [
-    GET >=> choose [
+    GET_HEAD >=> choose [
         route "/" >=> Post.home
     ]
     subRoute "/admin" (requireUser >=> choose [
-        GET >=> choose [
+        GET_HEAD >=> choose [
             subRoute "/categor" (choose [
                 route  "ies"       >=> Admin.listCategories
                 route  "ies/bare"  >=> Admin.listCategoriesBare
@@ -173,6 +143,10 @@ let router : HttpHandler = choose [
                 ])
             ])
             route    "/theme/update" >=> Admin.themeUpdatePage
+            subRoute "/upload" (choose [
+                route "s"    >=> Upload.list
+                route "/new" >=> Upload.showNew
+            ])
             route    "/user/edit"    >=> User.edit
         ]
         POST >=> validateCsrf >=> choose [
@@ -203,6 +177,11 @@ let router : HttpHandler = choose [
                 ])
             ])
             route    "/theme/update" >=> Admin.updateTheme
+            subRoute "/upload" (choose [
+                route   "/save"        >=> Upload.save
+                routexp "/delete/(.*)"     Upload.deleteFromDisk
+                routef  "/%s/delete"       Upload.deleteFromDb
+            ])
             route    "/user/save"    >=> User.save
         ]
     ])
@@ -210,7 +189,8 @@ let router : HttpHandler = choose [
     GET_HEAD >=> routef  "/page/%i"        Post.pageOfPosts
     GET_HEAD >=> routef  "/page/%i/"       Post.redirectToPageOfPosts       
     GET_HEAD >=> routexp "/tag/(.*)"       Post.pageOfTaggedPosts
-    GET_HEAD >=> routexp "/themes/(.*)"    Asset.serveAsset
+    GET_HEAD >=> routexp "/themes/(.*)"    Asset.serve
+    GET_HEAD >=> routexp "/upload/(.*)"    Upload.serve
     subRoute "/user" (choose [
         GET_HEAD >=> choose [
             route "/log-on"  >=> User.logOn None

src/MyWebLog/Handlers/Upload.fs

@@ -0,0 +1,215 @@
+/// Handlers to manipulate uploaded files
+module MyWebLog.Handlers.Upload
+
+open System
+open System.IO
+open Giraffe
+open Microsoft.AspNetCore.Http
+open Microsoft.Net.Http.Headers
+open MyWebLog
+
+/// Helper functions for this module
+[<AutoOpen>]
+module private Helpers =
+    
+    open Microsoft.AspNetCore.StaticFiles
+    
+    /// A MIME type mapper instance to use when serving files from the database
+    let mimeMap = FileExtensionContentTypeProvider ()
+
+    /// A cache control header that instructs the browser to cache the result for no more than 30 days
+    let cacheForThirtyDays =
+        let hdr = CacheControlHeaderValue()
+        hdr.MaxAge <- Some (TimeSpan.FromDays 30) |> Option.toNullable
+        hdr
+    
+    /// Shorthand for the directory separator
+    let slash = Path.DirectorySeparatorChar
+    
+    /// The base directory where uploads are stored, relative to the executable
+    let uploadDir = Path.Combine ("wwwroot", "upload")
+
+
+/// Determine if the file has been modified since the date/time specified by the If-Modified-Since header
+let checkModified since (ctx : HttpContext) : HttpHandler option =
+    match ctx.Request.Headers.IfModifiedSince with
+    | it when it.Count < 1 -> None
+    | it when since > DateTime.Parse it[0] -> None
+    | _ -> Some (setStatusCode 304 >=> setBodyFromString "Not Modified")
+
+
+open Microsoft.AspNetCore.Http.Headers
+
+/// Derive a MIME type based on the extension of the file
+let deriveMimeType path =
+    match mimeMap.TryGetContentType path with true, typ -> typ | false, _ -> "application/octet-stream"
+
+/// Send a file, caching the response for 30 days
+let sendFile updatedOn path (data : byte[]) : HttpHandler = fun next ctx -> task {
+    let headers = ResponseHeaders ctx.Response.Headers
+    headers.ContentType  <- (deriveMimeType >> MediaTypeHeaderValue) path
+    headers.CacheControl <- cacheForThirtyDays
+    let stream = new MemoryStream (data)
+    return! streamData true stream None (Some (DateTimeOffset updatedOn)) next ctx
+}
+
+// GET /upload/{web-log-slug}/{**path}
+let serve (urlParts : string seq) : HttpHandler = fun next ctx -> task {
+    let webLog = ctx.WebLog
+    let parts  = (urlParts |> Seq.skip 1 |> Seq.head).Split '/'
+    let slug   = Array.head parts
+    if slug = webLog.slug then
+        // Static file middleware will not work in subdirectories; check for an actual file first
+        let fileName = Path.Combine ("wwwroot", (Seq.head urlParts)[1..])
+        if File.Exists fileName then
+            return! streamFile true fileName None None next ctx
+        else
+            let path = String.Join ('/', Array.skip 1 parts)
+            match! ctx.Data.Upload.findByPath path webLog.id with
+            | Some upload ->
+                match checkModified upload.updatedOn ctx with
+                | Some threeOhFour -> return! threeOhFour next ctx
+                | None -> return! sendFile upload.updatedOn path upload.data next ctx
+            | None -> return! Error.notFound next ctx
+    else
+        return! Error.notFound next ctx
+}
+
+// ADMIN
+
+open System.Text.RegularExpressions
+open DotLiquid
+open MyWebLog.ViewModels
+
+/// Turn a string into a lowercase URL-safe slug
+let makeSlug it = ((Regex """\s+""").Replace ((Regex "[^A-z0-9 ]").Replace (it, ""), "-")).ToLowerInvariant ()
+
+// GET /admin/uploads
+let list : HttpHandler = fun next ctx -> task {
+    let  webLog      = ctx.WebLog
+    let! dbUploads   = ctx.Data.Upload.findByWebLog webLog.id
+    let  diskUploads =
+        let path = Path.Combine (uploadDir, webLog.slug)
+        try
+            Directory.EnumerateFiles (path, "*", SearchOption.AllDirectories)
+            |> Seq.map (fun file ->
+                let name = Path.GetFileName file
+                let create =
+                    match File.GetCreationTime (Path.Combine (path, file)) with
+                    | dt when dt > DateTime.UnixEpoch -> Some dt
+                    | _ -> None
+                { DisplayUpload.id = ""
+                  name             = name
+                  path             = file.Replace($"{path}{slash}", "").Replace(name, "").Replace (slash, '/')
+                  updatedOn        = create
+                  source           = UploadDestination.toString Disk
+                })
+            |> List.ofSeq
+        with
+        | :? DirectoryNotFoundException -> [] // This is fine
+        | ex ->
+            warn "Upload" ctx $"Encountered {ex.GetType().Name} listing uploads for {path}:\n{ex.Message}"
+            []
+    let allFiles =
+        dbUploads
+        |> List.map (DisplayUpload.fromUpload webLog Database)
+        |> List.append diskUploads
+        |> List.sortByDescending (fun file -> file.updatedOn, file.path)
+
+    return!
+        Hash.FromAnonymousObject {|
+            csrf       = csrfToken ctx
+            page_title = "Uploaded Files"
+            files      = allFiles
+        |}
+        |> viewForTheme "admin" "upload-list" next ctx
+    }
+
+// GET /admin/upload/new
+let showNew : HttpHandler = fun next ctx -> task {
+    return!
+        Hash.FromAnonymousObject {|
+            csrf        = csrfToken ctx
+            destination = UploadDestination.toString ctx.WebLog.uploads
+            page_title  = "Upload a File"
+        |}
+        |> viewForTheme "admin" "upload-new" next ctx
+}
+
+/// Redirect to the upload list
+let showUploads : HttpHandler = fun next ctx -> task {
+    return! redirectToGet (WebLog.relativeUrl ctx.WebLog (Permalink "admin/uploads")) next ctx
+}
+
+// POST /admin/upload/save
+let save : HttpHandler = fun next ctx -> task {
+    if ctx.Request.HasFormContentType && ctx.Request.Form.Files.Count > 0 then
+        let upload    = Seq.head ctx.Request.Form.Files
+        let fileName  = String.Concat (makeSlug (Path.GetFileNameWithoutExtension upload.FileName),
+                                       Path.GetExtension(upload.FileName).ToLowerInvariant ())
+        let  webLog   = ctx.WebLog
+        let  localNow = WebLog.localTime webLog DateTime.Now
+        let  year     = localNow.ToString "yyyy"
+        let  month    = localNow.ToString "MM"
+        let! form     = ctx.BindFormAsync<UploadFileModel> ()
+        
+        match UploadDestination.parse form.destination with
+        | Database ->
+            use stream = new MemoryStream ()
+            do! upload.CopyToAsync stream
+            let file =
+                { id        = UploadId.create ()
+                  webLogId  = webLog.id
+                  path      = Permalink $"{year}/{month}/{fileName}"
+                  updatedOn = DateTime.UtcNow
+                  data      = stream.ToArray ()
+                }
+            do! ctx.Data.Upload.add file
+        | Disk ->
+            let fullPath = Path.Combine (uploadDir, webLog.slug, year, month)
+            let _        = Directory.CreateDirectory fullPath
+            use stream   = new FileStream (Path.Combine (fullPath, fileName), FileMode.Create)
+            do! upload.CopyToAsync stream
+        
+        do! addMessage ctx { UserMessage.success with message = $"File uploaded to {form.destination} successfully" }
+        return! showUploads next ctx
+    else
+        return! RequestErrors.BAD_REQUEST "Bad request; no file present" next ctx
+}
+
+// POST /admin/upload/{id}/delete
+let deleteFromDb upId : HttpHandler = fun next ctx -> task {
+    let uploadId = UploadId upId
+    let webLog   = ctx.WebLog
+    let data     = ctx.Data
+    match! data.Upload.delete uploadId webLog.id with
+    | Ok fileName ->
+        do! addMessage ctx { UserMessage.success with message = $"{fileName} deleted successfully" }
+        return! showUploads next ctx
+    | Error _ -> return! Error.notFound next ctx
+}
+
+/// Remove a directory tree if it is empty
+let removeEmptyDirectories (webLog : WebLog) (filePath : string) =
+    let mutable path     = Path.GetDirectoryName filePath
+    let mutable finished = false
+    while (not finished) && path > "" do
+        let fullPath = Path.Combine (uploadDir, webLog.slug, path)
+        if Directory.EnumerateFileSystemEntries fullPath |> Seq.isEmpty then
+            Directory.Delete fullPath
+            path <- String.Join(slash, path.Split slash |> Array.rev |> Array.skip 1 |> Array.rev)
+        else
+            finished <- true
+    
+// POST /admin/upload/delete/{**path}
+let deleteFromDisk urlParts : HttpHandler = fun next ctx -> task {
+    let filePath = urlParts |> Seq.skip 1 |> Seq.head
+    let path = Path.Combine (uploadDir, ctx.WebLog.slug, filePath)
+    if File.Exists path then
+        File.Delete path
+        removeEmptyDirectories ctx.WebLog filePath
+        do! addMessage ctx { UserMessage.success with message = $"{filePath} deleted successfully" }
+        return! showUploads next ctx
+    else
+        return! Error.notFound next ctx
+}

src/MyWebLog/Maintenance.fs

@@ -23,11 +23,13 @@ let private doCreateWebLog (args : string[]) (sp : IServiceProvider) = task {
     let webLogId   = WebLogId.create ()
     let userId     = WebLogUserId.create ()
     let homePageId = PageId.create ()
+    let slug       = Handlers.Upload.makeSlug args[2]
     
     do! data.WebLog.add
             { WebLog.empty with
                 id          = webLogId
                 name        = args[2]
+                slug        = slug
                 urlBase     = args[1]
                 defaultPage = PageId.toString homePageId
                 timeZone    = timeZone
@@ -162,13 +164,48 @@ module Backup =
             }
     
         /// Create a theme asset from an encoded theme asset
-        static member fromAsset (asset : EncodedAsset) : ThemeAsset =
+        static member fromEncoded (encoded : EncodedAsset) : ThemeAsset =
-            { id        = asset.id
+            { id        = encoded.id
-              updatedOn = asset.updatedOn
+              updatedOn = encoded.updatedOn
-              data      = Convert.FromBase64String asset.data
+              data      = Convert.FromBase64String encoded.data
             }
     
+    /// An uploaded file, with the data base-64 encoded
+    type EncodedUpload =
+        {   /// The ID of the upload
+            id : UploadId
+            
+            /// The ID of the web log to which the upload belongs
+            webLogId : WebLogId
+            
+            /// The path at which this upload is served
+            path : Permalink
+            
+            /// The date/time this upload was last updated (file time)
+            updatedOn : DateTime
+            
+            /// The data for the upload, base-64 encoded
+            data : string
+        }
         
+        /// Create an encoded uploaded file from the original uploaded file
+        static member fromUpload (upload : Upload) : EncodedUpload =
+            { id        = upload.id
+              webLogId  = upload.webLogId
+              path      = upload.path
+              updatedOn = upload.updatedOn
+              data      = Convert.ToBase64String upload.data
+            }
+        
+        /// Create an uploaded file from an encoded uploaded file
+        static member fromEncoded (encoded : EncodedUpload) : Upload =
+            { id        = encoded.id
+              webLogId  = encoded.webLogId
+              path      = encoded.path
+              updatedOn = encoded.updatedOn
+              data      = Convert.FromBase64String encoded.data
+            }
+    
     /// A unified archive for a web log
     type Archive =
         {   /// The web log to which this archive belongs
@@ -194,6 +231,9 @@ module Backup =
             
             /// The posts for this web log (containing only the most recent revision)
             posts : Post list
+            
+            /// The uploaded files for this web log
+            uploads : EncodedUpload list
         }
     
     /// Create a JSON serializer (uses RethinkDB data implementation's JSON converters)
@@ -212,19 +252,21 @@ module Backup =
         let tagMapCount   = List.length archive.tagMappings
         let pageCount     = List.length archive.pages
         let postCount     = List.length archive.posts
+        let uploadCount   = List.length archive.uploads
         
         // Create a pluralized output based on the count
         let plural count ifOne ifMany =
             if count = 1 then ifOne else ifMany
             
         printfn ""
-        printfn $"""{msg.Replace ("{{NAME}}", webLog.name)}"""
+        printfn $"""{msg.Replace ("<>NAME<>", webLog.name)}"""
         printfn $""" - The theme "{archive.theme.name}" with {assetCount} asset{plural assetCount "" "s"}"""
         printfn $""" - {userCount} user{plural userCount "" "s"}"""
         printfn $""" - {categoryCount} categor{plural categoryCount "y" "ies"}"""
         printfn $""" - {tagMapCount} tag mapping{plural tagMapCount "" "s"}"""
         printfn $""" - {pageCount} page{plural pageCount "" "s"}"""
         printfn $""" - {postCount} post{plural postCount "" "s"}"""
+        printfn $""" - {uploadCount} uploaded file{plural uploadCount "" "s"}"""
 
     /// Create a backup archive
     let private createBackup webLog (fileName : string) prettyOutput (data : IData) = task {
@@ -248,6 +290,9 @@ module Backup =
         printfn "- Exporting posts..."
         let! posts = data.Post.findFullByWebLog webLog.id
         
+        printfn "- Exporting uploads..."
+        let! uploads = data.Upload.findByWebLogWithData webLog.id
+        
         printfn "- Writing archive..."
         let  archive    = {
             webLog      = webLog
@@ -256,8 +301,9 @@ module Backup =
             assets      = assets |> List.map EncodedAsset.fromAsset
             categories  = categories
             tagMappings = tagMaps
-            pages       = pages |> List.map (fun p -> { p with revisions = List.truncate 1 p.revisions })
+            pages       = pages   |> List.map (fun p -> { p with revisions = List.truncate 1 p.revisions })
-            posts       = posts |> List.map (fun p -> { p with revisions = List.truncate 1 p.revisions })
+            posts       = posts   |> List.map (fun p -> { p with revisions = List.truncate 1 p.revisions })
+            uploads     = uploads |> List.map EncodedUpload.fromUpload
         }
         
         // Write the structure to the backup file
@@ -267,7 +313,7 @@ module Backup =
         serializer.Serialize (writer, archive)
         writer.Close ()
         
-        displayStats "{{NAME}} backup contains:" webLog archive
+        displayStats $"{fileName} (for <>NAME<>) contains:" webLog archive
     }
     
     let private doRestore archive newUrlBase (data : IData) = task {
@@ -284,6 +330,7 @@ module Backup =
                 let newPageIds  = archive.pages       |> List.map (fun page -> page.id, PageId.create       ()) |> dict
                 let newPostIds  = archive.posts       |> List.map (fun post -> post.id, PostId.create       ()) |> dict
                 let newUserIds  = archive.users       |> List.map (fun user -> user.id, WebLogUserId.create ()) |> dict
+                let newUpIds    = archive.uploads     |> List.map (fun up   -> up.id,   UploadId.create     ()) |> dict
                 return
                     { archive with
                         webLog      = { archive.webLog with id = newWebLogId; urlBase = Option.get newUrlBase }
@@ -308,6 +355,8 @@ module Backup =
                                               authorId    = newUserIds[post.authorId]
                                               categoryIds = post.categoryIds |> List.map (fun c -> newCatIds[c])
                                           })
+                        uploads     = archive.uploads
+                                      |> List.map (fun u -> { u with id = newUpIds[u.id]; webLogId = newWebLogId })
                     }
             | None ->
                 return
@@ -320,7 +369,7 @@ module Backup =
         printfn ""
         printfn "- Importing theme..."
         do! data.Theme.save restore.theme
-        let! _ = restore.assets |> List.map (EncodedAsset.fromAsset >> data.ThemeAsset.save) |> Task.WhenAll
+        let! _ = restore.assets |> List.map (EncodedAsset.fromEncoded >> data.ThemeAsset.save) |> Task.WhenAll
         
         // Restore web log data
         
@@ -342,7 +391,10 @@ module Backup =
         
         // TODO: comments not yet implemented
         
-        displayStats "Restored for {{NAME}}:" restore.webLog restore
+        printfn "- Restoring uploads..."
+        do! data.Upload.restore (restore.uploads |> List.map EncodedUpload.fromEncoded)
+        
+        displayStats "Restored for <>NAME<>:" restore.webLog restore
     }
     
     /// Decide whether to restore a backup
@@ -371,17 +423,26 @@ module Backup =
         
     /// Generate a backup archive
     let generateBackup (args : string[]) (sp : IServiceProvider) = task {
-        if args.Length = 3 || args.Length = 4 then
+        let showUsage () =
+            printfn """Usage: MyWebLog backup [url-base] [*backup-file-name] [**"pretty"]"""
+            printfn """          * optional - default is [web-log-slug].json"""
+            printfn """         ** optional - default is non-pretty JSON output"""
+        if args.Length > 1 && args.Length < 5 then
             let data = sp.GetRequiredService<IData> ()
             match! data.WebLog.findByHost args[1] with
             | Some webLog ->
-                let fileName     = if args[2].EndsWith ".json" then args[2] else $"{args[2]}.json"
+                let fileName =
-                let prettyOutput = args.Length = 4 && args[3] = "pretty"
+                    if args.Length = 2 || (args.Length = 3 && args[2] = "pretty") then
+                        $"{webLog.slug}.json"
+                    elif args[2].EndsWith ".json" then
+                        args[2]
+                    else
+                        $"{args[2]}.json"
+                let prettyOutput = (args.Length = 3 && args[2] = "pretty") || (args.Length = 4 && args[3] = "pretty")
                 do! createBackup webLog fileName prettyOutput data
             | None -> printfn $"Error: no web log found for {args[1]}"
         else
-            printfn """Usage: MyWebLog backup [url-base] [backup-file-name] [*"pretty"]"""
+            showUsage ()
-            printfn """         * optional - default is non-pretty JSON output"""
     }
     
     /// Restore a backup archive

src/MyWebLog/MyWebLog.fsproj

@@ -18,6 +18,7 @@
     <Compile Include="Handlers\Feed.fs" />
     <Compile Include="Handlers\Post.fs" />
     <Compile Include="Handlers\User.fs" />
+    <Compile Include="Handlers\Upload.fs" />
     <Compile Include="Handlers\Routes.fs" />
     <Compile Include="DotLiquidBespoke.fs" />
     <Compile Include="Maintenance.fs" />
@@ -41,7 +42,7 @@
   </ItemGroup>
 
   <ItemGroup>
-    <None Include=".\wwwroot\img\*.png" CopyToOutputDirectory="Always" />
+    <None Include=".\wwwroot\upload\*" CopyToOutputDirectory="Always" />
   </ItemGroup>
 
 </Project>

src/MyWebLog/Program.fs

@@ -41,13 +41,17 @@ module DataImplementation =
     let get (sp : IServiceProvider) : IData =
         let config = sp.GetRequiredService<IConfiguration> ()
         if (config.GetConnectionString >> isNull >> not) "SQLite" then
+            let log  = sp.GetRequiredService<ILogger<SQLiteData>> ()
             let conn = new SqliteConnection (config.GetConnectionString "SQLite")
+            log.LogInformation $"Using SQL database {conn.DataSource}"
             SQLiteData.setUpConnection conn |> Async.AwaitTask |> Async.RunSynchronously
             upcast SQLiteData (conn, sp.GetRequiredService<ILogger<SQLiteData>> ())
         elif (config.GetSection "RethinkDB").Exists () then
+            let log = sp.GetRequiredService<ILogger<RethinkDbData>> ()
             Json.all () |> Seq.iter Converter.Serializer.Converters.Add 
             let rethinkCfg = DataConfig.FromConfiguration (config.GetSection "RethinkDB")
             let conn       = rethinkCfg.CreateConnectionAsync () |> Async.AwaitTask |> Async.RunSynchronously
+            log.LogInformation $"Using RethinkDB database {rethinkCfg.Database}"
             upcast RethinkDbData (conn, rethinkCfg, sp.GetRequiredService<ILogger<RethinkDbData>> ())
         else
             let log  = sp.GetRequiredService<ILogger<SQLiteData>> ()

src/MyWebLog/appsettings.json

@@ -1,5 +1,5 @@
 {
-  "Generator": "myWebLog 2.0-beta02",
+  "Generator": "myWebLog 2.0-beta03",
   "Logging": {
     "LogLevel": {
       "MyWebLog.Handlers": "Information"

src/admin-theme/_layout.liquid

@@ -12,6 +12,7 @@
             {{ "admin/dashboard" | nav_link: "Dashboard" }}
             {{ "admin/pages" | nav_link: "Pages" }}
             {{ "admin/posts" | nav_link: "Posts" }}
+            {{ "admin/uploads" | nav_link: "Uploads" }}
             {{ "admin/categories" | nav_link: "Categories" }}
             {{ "admin/settings" | nav_link: "Settings" }}
           </ul>

src/admin-theme/custom-feed-edit.liquid

@@ -185,7 +185,7 @@
                 </div>
               </div>
             </div>
-            <div class="row">
+            <div class="row pb-3">
               <div class="col-12 col-lg-10 offset-lg-1">
                 <div class="form-floating">
                   <input type="text" name="mediaBaseUrl" id="mediaBaseUrl" class="form-control"
@@ -195,6 +195,57 @@
                 </div>
               </div>
             </div>
+            <div class="row">
+              <div class="col-12 col-lg-5 offset-lg-1 pb-3">
+                <div class="form-floating">
+                  <input type="text" name="fundingUrl" id="fundingUrl" class="form-control" placeholder="Funding URL"
+                         value="{{ model.funding_url }}">
+                  <label for="fundingUrl">Funding URL</label>
+                  <span class="form-text fst-italic">
+                    Optional; URL describing donation options for this podcast, relative URL supported
+                  </span>
+                </div>
+              </div>
+              <div class="col-12 col-lg-5 pb-3">
+                <div class="form-floating">
+                  <input type="text" name="fundingText" id="fundingText" class="form-control" maxlength="128"
+                         placeholder="Funding Text" value="{{ model.funding_text }}">
+                  <label for="fundingText">Funding Text</label>
+                  <span class="form-text fst-italic">Optional; text for the funding link</span>
+                </div>
+              </div>
+            </div>
+            <div class="row pb-3">
+              <div class="col-8 col-lg-5 offset-lg-1 pb-3">
+                <div class="form-floating">
+                  <input type="text" name="guid" id="guid" class="form-control" placeholder="GUID"
+                         value="{{ model.guid }}">
+                  <label for="guid">Podcast GUID</label>
+                  <span class="form-text fst-italic">
+                    Optional; v5 UUID uniquely identifying this podcast; once entered, do not change this value
+                    (<a href="https://github.com/Podcastindex-org/podcast-namespace/blob/main/docs/1.0.md#guid"
+                        target="_blank">documentation</a>)
+                  </span>
+                </div>
+              </div>
+              <div class="col-4 col-lg-3 offset-lg-2 pb-3">
+                <div class="form-floating">
+                  <select name="medium" id="medium" class="form-control">
+                    {% for med in medium_values -%}
+                      <option value="{{ med[0] }}"{% if model.medium == med[0] %} selected{% endif %}>
+                        {{ med[1] }}
+                      </option>
+                    {%- endfor %}
+                  </select>
+                  <label for="medium">Medium</label>
+                  <span class="form-text fst-italic">
+                    Optional; medium of the podcast content
+                    (<a href="https://github.com/Podcastindex-org/podcast-namespace/blob/main/docs/1.0.md#medium"
+                        target="_blank">documentation</a>)
+                  </span>
+                </div>
+              </div>
+            </div>
           </fieldset>
         </div>
       </div>

src/admin-theme/post-list.liquid

@@ -42,7 +42,7 @@
             </span>
           </div>
           <div class="{{ title_col }}">
-            {%- if post.episode %}<span class="badge bg-success float-end text-uppercase">Episode</span>{% endif -%}
+            {%- if post.episode %}<span class="badge bg-success float-end text-uppercase mt-1">Episode</span>{% endif -%}
             {{ post.title }}<br>
             <small>
               <a href="{{ post | relative_link }}" target="_blank">View Post</a>

src/admin-theme/settings.liquid

@@ -8,26 +8,33 @@
     <input type="hidden" name="{{ csrf.form_field_name }}" value="{{ csrf.request_token }}">
     <div class="container">
       <div class="row">
-        <div class="col-12 col-md-6 col-xl-4 offset-xl-1 pb-3">
+        <div class="col-12 col-md-6 col-xl-4 pb-3">
           <div class="form-floating">
-            <input type="text" name="name" id="name" class="form-control" value="{{ model.name }}" required autofocus>
+            <input type="text" name="name" id="name" class="form-control" placeholder="Name" required autofocus
+                   value="{{ model.name }}">
             <label for="name">Name</label>
           </div>
         </div>
         <div class="col-12 col-md-6 col-xl-4 pb-3">
           <div class="form-floating">
-            <input type="text" name="subtitle" id="subtitle" class="form-control" value="{{ model.subtitle }}">
+            <input type="text" name="slug" id="slug" class="form-control" placeholder="Slug" required
+                   value="{{ model.slug }}">
+            <label for="slug">Slug</label>
+            <span class="form-text">
+              <span class="badge rounded-pill bg-warning text-dark">WARNING</span> changing this value may break links
+              (<a href="https://bitbadger.solutions/open-source/myweblog/configuring.html#blog-settings"
+                  target="_blank">more</a>)
+            </span>
+          </div>
+        </div>
+        <div class="col-12 col-md-6 col-xl-4 pb-3">
+          <div class="form-floating">
+            <input type="text" name="subtitle" id="subtitle" class="form-control" placeholder="Subtitle"
+                   value="{{ model.subtitle }}">
             <label for="subtitle">Subtitle</label>
           </div>
         </div>
-        <div class="col-12 col-md-4 col-xl-2 pb-3">
+        <div class="col-12 col-md-6 col-xl-4 offset-xl-1 pb-3">
-          <div class="form-floating">
-            <input type="number" name="postsPerPage" id="postsPerPage" class="form-control" min="0" max="50" required
-                   value="{{ model.posts_per_page }}">
-            <label for="postsPerPage">Posts per Page</label>
-          </div>
-        </div>
-        <div class="col-12 col-md-4 col-xl-3 pb-3">
           <div class="form-floating">
             <select name="themePath" id="themePath" class="form-control" required>
               {% for theme in themes -%}
@@ -39,19 +46,12 @@
             <label for="themePath">Theme</label>
           </div>
         </div>
-        <div class="col-12 col-md-4 col-xl-3 pb-3">
+        <div class="col-12 col-md-6 offset-md-1 col-xl-4 offset-xl-0 pb-3">
-          <div class="form-floating">
-            <input type="text" name="timeZone" id="timeZone" class="form-control" required
-                   value="{{ model.time_zone }}">
-            <label for="timeZone">Time Zone</label>
-          </div>
-        </div>
-        <div class="col-12 col-md-4 pb-3">
           <div class="form-floating">
             <select name="defaultPage" id="defaultPage" class="form-control" required>
               {% for pg in pages -%}
                 <option value="{{ pg[0] }}"
-                        {%- if pg[0] == model.default_page  %} selected="selected"{% endif %}>
+                {%- if pg[0] == model.default_page  %} selected="selected"{% endif %}>
                   {{ pg[1] }}
                 </option>
               {%- endfor %}
@@ -59,6 +59,22 @@
             <label for="defaultPage">Default Page</label>
           </div>
         </div>
+        <div class="col-12 col-md-4 col-xl-2 pb-3">
+          <div class="form-floating">
+            <input type="number" name="postsPerPage" id="postsPerPage" class="form-control" min="0" max="50" required
+                   value="{{ model.posts_per_page }}">
+            <label for="postsPerPage">Posts per Page</label>
+          </div>
+        </div>
+      </div>
+      <div class="row">
+        <div class="col-12 col-md-4 col-xl-3 offset-xl-2 pb-3">
+          <div class="form-floating">
+            <input type="text" name="timeZone" id="timeZone" class="form-control" placeholder="Time Zone" required
+                   value="{{ model.time_zone }}">
+            <label for="timeZone">Time Zone</label>
+          </div>
+        </div>
         <div class="col-12 col-md-4 col-xl-2">
           <div class="form-check form-switch">
             <input type="checkbox" name="autoHtmx" id="autoHtmx" class="form-check-input" value="true"
@@ -69,6 +85,16 @@
             <a href="https://htmx.org" target="_blank" rel="noopener">What is this?</a>
           </span>
         </div>
+        <div class="col-12 col-md-4 col-xl-3 pb-3">
+          <div class="form-floating">
+            <select name="uploads" id="uploads" class="form-control">
+              {%- for it in upload_values %}
+                <option value="{{ it[0] }}"{% if model.uploads == it[0] %} selected{% endif %}>{{ it[1] }}</option>
+              {%- endfor %}
+            </select>
+            <label for="uploads">Default Upload Destination</label>
+          </div>
+        </div>
       </div>
       <div class="row pb-3">
         <div class="col text-center">

src/admin-theme/upload-list.liquid

@@ -0,0 +1,73 @@
+<h2 class="my-3">{{ page_title }}</h2>
+<article>
+  {%- capture base_url %}{{ "" | relative_link }}{% endcapture -%}
+  {%- capture upload_path %}upload/{{ web_log.slug }}/{% endcapture -%}
+  {%- capture upload_base %}{{ base_url }}{{ upload_path }}{% endcapture -%}
+  <a href="{{ "admin/upload/new" | relative_link }}" class="btn btn-primary btn-sm mb-3">Upload a New File</a>
+  <form method="post" class="container" hx-target="body">
+    <input type="hidden" name="{{ csrf.form_field_name }}" value="{{ csrf.request_token }}">
+    <div class="row">
+      <div class="col text-muted text-center"><em>Uploaded files served from</em><br>{{ upload_base }}</div>
+    </div>
+    <div class="row mwl-table-heading">
+      <div class="col-6">File Name</div>
+      <div class="col-3">Path</div>
+      <div class="col-3">File Date/Time</div>
+    </div>
+    {%- assign file_count = files | size -%}
+    {%- if file_count > 0 %}
+      {% for file in files %}
+        <div class="row mwl-table-detail">
+          <div class="col-6">
+            {%- capture badge_class -%}
+              {%- if file.source == "disk" %}secondary{% else %}primary{% endif -%}
+            {%- endcapture -%}
+            {%- capture rel_url %}{{ upload_base }}{{ file.path }}{{ file.name }}{% endcapture -%}
+            {%- capture blog_rel %}{{ upload_path }}{{ file.path }}{{ file.name }}{% endcapture -%}
+            <span class="badge bg-{{ badge_class }} text-uppercase float-end mt-1">{{ file.source }}</span>
+            {{ file.name }}<br>
+            <small>
+              <a href="{{ rel_url }}" target="_blank">View File</a>
+              <span class="text-muted"> &bull; Copy </span>
+              <a href="{{ blog_rel | absolute_link }}" hx-boost="false"
+                 onclick="return Admin.copyText('{{ blog_rel | absolute_link }}', this)">
+                Absolute
+              </a>
+              <span class="text-muted"> | </span>
+              <a href="{{ blog_rel | relative_link }}" hx-boost="false"
+                 onclick="return Admin.copyText('{{ blog_rel | relative_link }}', this)">
+                Relative
+              </a>
+              {%- unless base_url == "/" %}
+                <span class="text-muted"> | </span>
+                <a href="{{ blog_rel }}" hx-boost="false"
+                   onclick="return Admin.copyText('/{{ blog_rel }}', this)">
+                  For Post
+                </a>
+              {%- endunless %}
+              <span class="text-muted"> Link &bull; </span>
+              {%- capture delete_url -%}
+                {%- if file.source == "disk" -%}
+                  admin/upload/delete/{{ file.path }}{{ file.name }}
+                {%- else -%}
+                  admin/upload/{{ file.id }}/delete
+                {%- endif -%}
+              {%- endcapture -%}
+              <a href="{{ delete_url | relative_link }}" hx-post="{{ delete_url | relative_link }}"
+                 hx-confirm="Are you sure you want to delete {{ file.name }}? This action cannot be undone."
+                 class="text-danger">Delete</a>
+            </small>
+          </div>
+          <div class="col-3">{{ file.path }}</div>
+          <div class="col-3">
+            {% if file.updated_on %}{{ file.updated_on.value | date: "yyyy-MM-dd/HH:mm" }}{% else %}--{% endif %}
+          </div>
+        </div>
+      {% endfor %}
+    {%- else -%}
+      <div class="row">
+        <div class="col text-muted fst-italic text-center">This web log has uploaded files</div>
+      </div>
+    {%- endif %}
+  </form>
+</article>

src/admin-theme/upload-new.liquid

@@ -0,0 +1,31 @@
+<h2>{{ page_title }}</h2>
+<article>
+  <form action="{{ "admin/upload/save" | relative_link }}"
+        method="post" class="container" enctype="multipart/form-data" hx-boost="false">
+    <input type="hidden" name="{{ csrf.form_field_name }}" value="{{ csrf.request_token }}">
+    <div class="row">
+      <div class="col-12 col-md-6 pb-3">
+        <div class="form-floating">
+          <input type="file" id="file" name="file" class="form-control" placeholder="File" required>
+          <label for="file">File to Upload</label>
+        </div>
+      </div>
+      <div class="col-12 col-md-6 pb-3 d-flex align-self-center justify-content-around">
+        Destination<br>
+        <div class="btn-group" role="group" aria-label="Upload destination button group">
+          <input type="radio" name="destination" id="destination_db" class="btn-check" value="database"
+          {%- if destination == "database" %} checked="checked"{% endif %}>
+          <label class="btn btn-outline-primary" for="destination_db">Database</label>
+          <input type="radio" name="destination" id="destination_disk" class="btn-check" value="disk"
+          {%- if destination == "disk" %} checked="checked"{% endif %}>
+          <label class="btn btn-outline-secondary" for="destination_disk">Disk</label>
+        </div>
+      </div>
+    </div>
+    <div class="row pb-3">
+      <div class="col text-center">
+        <button type="submit" class="btn btn-primary">Upload File</button>
+      </div>
+    </div>
+  </form>
+</article>

src/admin-theme/version.txt

@@ -1,2 +1,2 @@
 myWebLog Admin
-2.0.0-beta02
+2.0.0-beta03

src/admin-theme/wwwroot/admin.js

@@ -1,13 +1,22 @@
-const Admin = {
+/**
-  /** The next index for a metadata item */
+ * Support functions for the administrative UI
+ */
+this.Admin = {
+  /**
+   * The next index for a metadata item
+   * @type {number}
+   */
   nextMetaIndex : 0,
 
-  /** The next index for a permalink */
+  /**
+   * The next index for a permalink
+   * @type {number}
+   */
   nextPermalink : 0,
   
   /**
    * Set the next meta item index
-   * @param idx The index to set
+   * @param {number} idx The index to set
    */
   setNextMetaIndex(idx) {
     this.nextMetaIndex = idx
@@ -15,7 +24,7 @@
 
   /**
    * Set the next permalink index
-   * @param idx The index to set
+   * @param {number} idx The index to set
    */
   setPermalinkIndex(idx) {
     this.nextPermalink = idx
@@ -220,10 +229,22 @@
   checkPodcast() {
     document.getElementById("podcastFields").disabled = !document.getElementById("isPodcast").checked
   },
+
+  /**
+   * Copy text to the clipboard
+   * @param {string} text The text to be copied
+   * @param {HTMLAnchorElement} elt The element on which the click was generated
+   * @return {boolean} False, to prevent navigation
+   */
+  copyText(text, elt) {
+    navigator.clipboard.writeText(text)
+    elt.innerText = "Copied"
+    return false
+  },
   
   /**
    * Toggle the source of a custom RSS feed
-   * @param source The source that was selected
+   * @param {string} source The source that was selected
    */
   customFeedBy(source) {
     const categoryInput = document.getElementById("sourceValueCat")
@@ -241,7 +262,7 @@
   
   /**
    * Remove a metadata item
-   * @param idx The index of the metadata item to remove
+   * @param {number} idx The index of the metadata item to remove
    */
   removeMetaItem(idx) {
     document.getElementById(`meta_${idx}`).remove()
@@ -249,7 +270,7 @@
 
   /**
    * Remove a permalink
-   * @param idx The index of the permalink to remove
+   * @param {number} idx The index of the permalink to remove
    */
   removePermalink(idx) {
     document.getElementById(`link_${idx}`).remove()
@@ -264,7 +285,7 @@
 
   /**
    * Show messages that may have come with an htmx response
-   * @param messages The messages from the response
+   * @param {string} messages The messages from the response
    */
   showMessage(messages) {
     const msgs = messages.split(", ")