Daniel J. Summers
dc6b066e79
- Begin moving auth to route definition where practical - Fix typo on post list page
1252 lines
44 KiB
Forth
1252 lines
44 KiB
Forth
namespace MyWebLog.ViewModels
|
|
|
|
open System
|
|
open MyWebLog
|
|
open NodaTime
|
|
|
|
/// Helper functions for view models
|
|
[<AutoOpen>]
|
|
module private Helpers =
|
|
|
|
/// Create a string option if a string is blank
|
|
let noneIfBlank (it : string) =
|
|
match (defaultArg (Option.ofObj it) "").Trim () with "" -> None | trimmed -> Some trimmed
|
|
|
|
|
|
/// Helper functions that are needed outside this file
|
|
[<AutoOpen>]
|
|
module PublicHelpers =
|
|
|
|
/// If the web log is not being served from the domain root, add the path information to relative URLs in page and
|
|
/// post text
|
|
let addBaseToRelativeUrls extra (text : string) =
|
|
if extra = "" then text
|
|
else text.Replace("href=\"/", $"href=\"{extra}/").Replace ("src=\"/", $"src=\"{extra}/")
|
|
|
|
|
|
/// 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 =
|
|
{ /// The ID of the category
|
|
Id : string
|
|
|
|
/// The slug for the category
|
|
Slug : string
|
|
|
|
/// The name of the category
|
|
Name : string
|
|
|
|
/// A description of the category
|
|
Description : string option
|
|
|
|
/// The parent category names for this (sub)category
|
|
ParentNames : string[]
|
|
|
|
/// The number of posts in this category
|
|
PostCount : int
|
|
}
|
|
|
|
|
|
/// A display version of a custom feed definition
|
|
type DisplayCustomFeed =
|
|
{ /// The ID of the custom feed
|
|
Id : string
|
|
|
|
/// The source of the custom feed
|
|
Source : string
|
|
|
|
/// The relative path at which the custom feed is served
|
|
Path : string
|
|
|
|
/// Whether this custom feed is for a podcast
|
|
IsPodcast : bool
|
|
}
|
|
|
|
/// Create a display version from a custom feed
|
|
static member fromFeed (cats : DisplayCategory[]) (feed : CustomFeed) : DisplayCustomFeed =
|
|
let source =
|
|
match feed.Source with
|
|
| Category (CategoryId catId) -> $"Category: {(cats |> Array.find (fun cat -> cat.Id = catId)).Name}"
|
|
| Tag tag -> $"Tag: {tag}"
|
|
{ Id = CustomFeedId.toString feed.Id
|
|
Source = source
|
|
Path = Permalink.toString feed.Path
|
|
IsPodcast = Option.isSome feed.Podcast
|
|
}
|
|
|
|
|
|
/// Details about a page used to display page lists
|
|
[<NoComparison; NoEquality>]
|
|
type DisplayPage =
|
|
{ /// The ID of this page
|
|
Id : string
|
|
|
|
/// The ID of the author of this page
|
|
AuthorId : string
|
|
|
|
/// The title of the page
|
|
Title : string
|
|
|
|
/// The link at which this page is displayed
|
|
Permalink : string
|
|
|
|
/// When this page was published
|
|
PublishedOn : DateTime
|
|
|
|
/// When this page was last updated
|
|
UpdatedOn : DateTime
|
|
|
|
/// Whether this page shows as part of the web log's navigation
|
|
IsInPageList : bool
|
|
|
|
/// Is this the default page?
|
|
IsDefault : bool
|
|
|
|
/// The text of the page
|
|
Text : string
|
|
|
|
/// The metadata for the page
|
|
Metadata : MetaItem list
|
|
}
|
|
|
|
/// Create a minimal display page (no text or metadata) from a database page
|
|
static member fromPageMinimal webLog (page : Page) =
|
|
let pageId = PageId.toString page.Id
|
|
{ Id = pageId
|
|
AuthorId = WebLogUserId.toString page.AuthorId
|
|
Title = page.Title
|
|
Permalink = Permalink.toString page.Permalink
|
|
PublishedOn = WebLog.localTime webLog page.PublishedOn
|
|
UpdatedOn = WebLog.localTime webLog page.UpdatedOn
|
|
IsInPageList = page.IsInPageList
|
|
IsDefault = pageId = webLog.DefaultPage
|
|
Text = ""
|
|
Metadata = []
|
|
}
|
|
|
|
/// Create a display page from a database page
|
|
static member fromPage webLog (page : Page) =
|
|
let _, extra = WebLog.hostAndPath webLog
|
|
let pageId = PageId.toString page.Id
|
|
{ Id = pageId
|
|
AuthorId = WebLogUserId.toString page.AuthorId
|
|
Title = page.Title
|
|
Permalink = Permalink.toString page.Permalink
|
|
PublishedOn = WebLog.localTime webLog page.PublishedOn
|
|
UpdatedOn = WebLog.localTime webLog page.UpdatedOn
|
|
IsInPageList = page.IsInPageList
|
|
IsDefault = pageId = webLog.DefaultPage
|
|
Text = addBaseToRelativeUrls extra page.Text
|
|
Metadata = page.Metadata
|
|
}
|
|
|
|
|
|
/// Information about a revision used for display
|
|
[<NoComparison; NoEquality>]
|
|
type DisplayRevision =
|
|
{ /// The as-of date/time for the revision
|
|
AsOf : DateTime
|
|
|
|
/// The as-of date/time for the revision in the web log's local time zone
|
|
AsOfLocal : DateTime
|
|
|
|
/// The format of the text of the revision
|
|
Format : string
|
|
}
|
|
with
|
|
|
|
/// Create a display revision from an actual revision
|
|
static member fromRevision webLog (rev : Revision) =
|
|
{ AsOf = rev.AsOf.ToDateTimeUtc ()
|
|
AsOfLocal = WebLog.localTime webLog rev.AsOf
|
|
Format = MarkupText.sourceType rev.Text
|
|
}
|
|
|
|
|
|
open System.IO
|
|
|
|
/// Information about a theme used for display
|
|
[<NoComparison; NoEquality>]
|
|
type DisplayTheme =
|
|
{ /// The ID / path slug of the theme
|
|
Id : string
|
|
|
|
/// The name of the theme
|
|
Name : string
|
|
|
|
/// The version of the theme
|
|
Version : string
|
|
|
|
/// How many templates are contained in the theme
|
|
TemplateCount : int
|
|
|
|
/// Whether the theme is in use by any web logs
|
|
IsInUse : bool
|
|
|
|
/// Whether the theme .zip file exists on the filesystem
|
|
IsOnDisk : bool
|
|
}
|
|
with
|
|
|
|
/// Create a display theme from a theme
|
|
static member fromTheme inUseFunc (theme : Theme) =
|
|
{ Id = ThemeId.toString theme.Id
|
|
Name = theme.Name
|
|
Version = theme.Version
|
|
TemplateCount = List.length theme.Templates
|
|
IsInUse = inUseFunc theme.Id
|
|
IsOnDisk = File.Exists $"{ThemeId.toString theme.Id}-theme.zip"
|
|
}
|
|
|
|
|
|
/// Information about an uploaded file used for display
|
|
[<NoComparison; NoEquality>]
|
|
type DisplayUpload =
|
|
{ /// The ID of the uploaded file
|
|
Id : string
|
|
|
|
/// The name of the uploaded file
|
|
Name : string
|
|
|
|
/// The path at which the file is served
|
|
Path : string
|
|
|
|
/// The date/time the file was updated
|
|
UpdatedOn : DateTime option
|
|
|
|
/// The source for this file (created from UploadDestination DU)
|
|
Source : string
|
|
}
|
|
|
|
/// 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 to display a user's information
|
|
[<NoComparison; NoEquality>]
|
|
type DisplayUser =
|
|
{ /// The ID of the user
|
|
Id : string
|
|
|
|
/// The user name (e-mail address)
|
|
Email : string
|
|
|
|
/// The user's first name
|
|
FirstName : string
|
|
|
|
/// The user's last name
|
|
LastName : string
|
|
|
|
/// The user's preferred name
|
|
PreferredName : string
|
|
|
|
/// The URL of the user's personal site
|
|
Url : string
|
|
|
|
/// The user's access level
|
|
AccessLevel : string
|
|
|
|
/// When the user was created
|
|
CreatedOn : DateTime
|
|
|
|
/// When the user last logged on
|
|
LastSeenOn : Nullable<DateTime>
|
|
}
|
|
|
|
/// Construct a displayed user from a web log user
|
|
static member fromUser webLog (user : WebLogUser) =
|
|
{ Id = WebLogUserId.toString user.Id
|
|
Email = user.Email
|
|
FirstName = user.FirstName
|
|
LastName = user.LastName
|
|
PreferredName = user.PreferredName
|
|
Url = defaultArg user.Url ""
|
|
AccessLevel = AccessLevel.toString user.AccessLevel
|
|
CreatedOn = WebLog.localTime webLog user.CreatedOn
|
|
LastSeenOn = user.LastSeenOn |> Option.map (WebLog.localTime webLog) |> Option.toNullable
|
|
}
|
|
|
|
|
|
/// View model for editing categories
|
|
[<CLIMutable; NoComparison; NoEquality>]
|
|
type EditCategoryModel =
|
|
{ /// The ID of the category being edited
|
|
CategoryId : string
|
|
|
|
/// The name of the category
|
|
Name : string
|
|
|
|
/// The category's URL slug
|
|
Slug : string
|
|
|
|
/// A description of the category (optional)
|
|
Description : string
|
|
|
|
/// The ID of the category for which this is a subcategory (optional)
|
|
ParentId : string
|
|
}
|
|
|
|
/// Create an edit model from an existing category
|
|
static member fromCategory (cat : Category) =
|
|
{ CategoryId = CategoryId.toString cat.Id
|
|
Name = cat.Name
|
|
Slug = cat.Slug
|
|
Description = defaultArg cat.Description ""
|
|
ParentId = cat.ParentId |> Option.map CategoryId.toString |> Option.defaultValue ""
|
|
}
|
|
|
|
/// Is this a new category?
|
|
member this.IsNew = this.CategoryId = "new"
|
|
|
|
|
|
/// View model to edit a custom RSS feed
|
|
[<CLIMutable; NoComparison; NoEquality>]
|
|
type EditCustomFeedModel =
|
|
{ /// The ID of the feed being editing
|
|
Id : string
|
|
|
|
/// The type of source for this feed ("category" or "tag")
|
|
SourceType : string
|
|
|
|
/// The category ID or tag on which this feed is based
|
|
SourceValue : string
|
|
|
|
/// The relative path at which this feed is served
|
|
Path : string
|
|
|
|
/// Whether this feed defines a podcast
|
|
IsPodcast : bool
|
|
|
|
/// The title of the podcast
|
|
Title : string
|
|
|
|
/// A subtitle for the podcast
|
|
Subtitle : string
|
|
|
|
/// The number of items in the podcast feed
|
|
ItemsInFeed : int
|
|
|
|
/// A summary of the podcast (iTunes field)
|
|
Summary : string
|
|
|
|
/// The display name of the podcast author (iTunes field)
|
|
DisplayedAuthor : string
|
|
|
|
/// The e-mail address of the user who registered the podcast at iTunes
|
|
Email : string
|
|
|
|
/// The link to the image for the podcast
|
|
ImageUrl : string
|
|
|
|
/// The category from Apple Podcasts (iTunes) under which this podcast is categorized
|
|
AppleCategory : string
|
|
|
|
/// A further refinement of the categorization of this podcast (Apple Podcasts/iTunes field / values)
|
|
AppleSubcategory : string
|
|
|
|
/// The explictness rating (iTunes field)
|
|
Explicit : string
|
|
|
|
/// The default media type for files in this podcast
|
|
DefaultMediaType : string
|
|
|
|
/// 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
|
|
PodcastGuid : string
|
|
|
|
/// The medium for the content of this podcast
|
|
Medium : string
|
|
}
|
|
|
|
/// An empty custom feed model
|
|
static member empty =
|
|
{ Id = ""
|
|
SourceType = "category"
|
|
SourceValue = ""
|
|
Path = ""
|
|
IsPodcast = false
|
|
Title = ""
|
|
Subtitle = ""
|
|
ItemsInFeed = 25
|
|
Summary = ""
|
|
DisplayedAuthor = ""
|
|
Email = ""
|
|
ImageUrl = ""
|
|
AppleCategory = ""
|
|
AppleSubcategory = ""
|
|
Explicit = "no"
|
|
DefaultMediaType = "audio/mpeg"
|
|
MediaBaseUrl = ""
|
|
FundingUrl = ""
|
|
FundingText = ""
|
|
PodcastGuid = ""
|
|
Medium = ""
|
|
}
|
|
|
|
/// Create a model from a custom feed
|
|
static member fromFeed (feed : CustomFeed) =
|
|
let rss =
|
|
{ EditCustomFeedModel.empty with
|
|
Id = CustomFeedId.toString feed.Id
|
|
SourceType = match feed.Source with Category _ -> "category" | Tag _ -> "tag"
|
|
SourceValue = match feed.Source with Category (CategoryId catId) -> catId | Tag tag -> tag
|
|
Path = Permalink.toString feed.Path
|
|
}
|
|
match feed.Podcast with
|
|
| Some p ->
|
|
{ rss with
|
|
IsPodcast = true
|
|
Title = p.Title
|
|
Subtitle = defaultArg p.Subtitle ""
|
|
ItemsInFeed = p.ItemsInFeed
|
|
Summary = p.Summary
|
|
DisplayedAuthor = p.DisplayedAuthor
|
|
Email = p.Email
|
|
ImageUrl = Permalink.toString p.ImageUrl
|
|
AppleCategory = p.AppleCategory
|
|
AppleSubcategory = defaultArg p.AppleSubcategory ""
|
|
Explicit = ExplicitRating.toString p.Explicit
|
|
DefaultMediaType = defaultArg p.DefaultMediaType ""
|
|
MediaBaseUrl = defaultArg p.MediaBaseUrl ""
|
|
FundingUrl = defaultArg p.FundingUrl ""
|
|
FundingText = defaultArg p.FundingText ""
|
|
PodcastGuid = p.PodcastGuid
|
|
|> Option.map (fun it -> it.ToString().ToLowerInvariant ())
|
|
|> Option.defaultValue ""
|
|
Medium = p.Medium |> Option.map PodcastMedium.toString |> Option.defaultValue ""
|
|
}
|
|
| None -> rss
|
|
|
|
/// Update a feed with values from this model
|
|
member this.UpdateFeed (feed : CustomFeed) =
|
|
{ feed with
|
|
Source = if this.SourceType = "tag" then Tag this.SourceValue else Category (CategoryId this.SourceValue)
|
|
Path = Permalink this.Path
|
|
Podcast =
|
|
if this.IsPodcast then
|
|
Some {
|
|
Title = this.Title
|
|
Subtitle = noneIfBlank this.Subtitle
|
|
ItemsInFeed = this.ItemsInFeed
|
|
Summary = this.Summary
|
|
DisplayedAuthor = this.DisplayedAuthor
|
|
Email = this.Email
|
|
ImageUrl = Permalink this.ImageUrl
|
|
AppleCategory = this.AppleCategory
|
|
AppleSubcategory = noneIfBlank this.AppleSubcategory
|
|
Explicit = ExplicitRating.parse this.Explicit
|
|
DefaultMediaType = noneIfBlank this.DefaultMediaType
|
|
MediaBaseUrl = noneIfBlank this.MediaBaseUrl
|
|
PodcastGuid = noneIfBlank this.PodcastGuid |> Option.map Guid.Parse
|
|
FundingUrl = noneIfBlank this.FundingUrl
|
|
FundingText = noneIfBlank this.FundingText
|
|
Medium = noneIfBlank this.Medium |> Option.map PodcastMedium.parse
|
|
}
|
|
else
|
|
None
|
|
}
|
|
|
|
|
|
/// View model for a user to edit their own information
|
|
[<CLIMutable; NoComparison; NoEquality>]
|
|
type EditMyInfoModel =
|
|
{ /// The user's first name
|
|
FirstName : string
|
|
|
|
/// The user's last name
|
|
LastName : string
|
|
|
|
/// The user's preferred name
|
|
PreferredName : string
|
|
|
|
/// A new password for the user
|
|
NewPassword : string
|
|
|
|
/// A new password for the user, confirmed
|
|
NewPasswordConfirm : string
|
|
}
|
|
|
|
/// Create an edit model from a user
|
|
static member fromUser (user : WebLogUser) =
|
|
{ FirstName = user.FirstName
|
|
LastName = user.LastName
|
|
PreferredName = user.PreferredName
|
|
NewPassword = ""
|
|
NewPasswordConfirm = ""
|
|
}
|
|
|
|
|
|
/// View model to edit a page
|
|
[<CLIMutable; NoComparison; NoEquality>]
|
|
type EditPageModel =
|
|
{ /// The ID of the page being edited
|
|
PageId : string
|
|
|
|
/// The title of the page
|
|
Title : string
|
|
|
|
/// The permalink for the page
|
|
Permalink : string
|
|
|
|
/// The template to use to display the page
|
|
Template : string
|
|
|
|
/// Whether this page is shown in the page list
|
|
IsShownInPageList : bool
|
|
|
|
/// The source format for the text
|
|
Source : string
|
|
|
|
/// The text of the page
|
|
Text : string
|
|
|
|
/// Names of metadata items
|
|
MetaNames : string[]
|
|
|
|
/// Values of metadata items
|
|
MetaValues : string[]
|
|
}
|
|
|
|
/// Create an edit model from an existing page
|
|
static member fromPage (page : Page) =
|
|
let latest =
|
|
match page.Revisions |> List.sortByDescending (fun r -> r.AsOf) |> List.tryHead with
|
|
| Some rev -> rev
|
|
| None -> Revision.empty
|
|
let page = if page.Metadata |> List.isEmpty then { page with Metadata = [ MetaItem.empty ] } else page
|
|
{ PageId = PageId.toString page.Id
|
|
Title = page.Title
|
|
Permalink = Permalink.toString page.Permalink
|
|
Template = defaultArg page.Template ""
|
|
IsShownInPageList = page.IsInPageList
|
|
Source = MarkupText.sourceType latest.Text
|
|
Text = MarkupText.text latest.Text
|
|
MetaNames = page.Metadata |> List.map (fun m -> m.Name) |> Array.ofList
|
|
MetaValues = page.Metadata |> List.map (fun m -> m.Value) |> Array.ofList
|
|
}
|
|
|
|
/// Whether this is a new page
|
|
member this.IsNew = this.PageId = "new"
|
|
|
|
/// Update a page with values from this model
|
|
member this.UpdatePage (page : Page) now =
|
|
let revision = { AsOf = now; Text = MarkupText.parse $"{this.Source}: {this.Text}" }
|
|
// Detect a permalink change, and add the prior one to the prior list
|
|
match Permalink.toString page.Permalink with
|
|
| "" -> page
|
|
| link when link = this.Permalink -> page
|
|
| _ -> { page with PriorPermalinks = page.Permalink :: page.PriorPermalinks }
|
|
|> function
|
|
| page ->
|
|
{ page with
|
|
Title = this.Title
|
|
Permalink = Permalink this.Permalink
|
|
UpdatedOn = now
|
|
IsInPageList = this.IsShownInPageList
|
|
Template = match this.Template with "" -> None | tmpl -> Some tmpl
|
|
Text = MarkupText.toHtml revision.Text
|
|
Metadata = Seq.zip this.MetaNames this.MetaValues
|
|
|> Seq.filter (fun it -> fst it > "")
|
|
|> Seq.map (fun it -> { Name = fst it; Value = snd it })
|
|
|> Seq.sortBy (fun it -> $"{it.Name.ToLower ()} {it.Value.ToLower ()}")
|
|
|> List.ofSeq
|
|
Revisions = match page.Revisions |> List.tryHead with
|
|
| Some r when r.Text = revision.Text -> page.Revisions
|
|
| _ -> revision :: page.Revisions
|
|
}
|
|
|
|
|
|
/// View model to edit a post
|
|
[<CLIMutable; NoComparison; NoEquality>]
|
|
type EditPostModel =
|
|
{ /// The ID of the post being edited
|
|
PostId : string
|
|
|
|
/// The title of the post
|
|
Title : string
|
|
|
|
/// The permalink for the post
|
|
Permalink : string
|
|
|
|
/// The source format for the text
|
|
Source : string
|
|
|
|
/// The text of the post
|
|
Text : string
|
|
|
|
/// The tags for the post
|
|
Tags : string
|
|
|
|
/// The template used to display the post
|
|
Template : string
|
|
|
|
/// The category IDs for the post
|
|
CategoryIds : string[]
|
|
|
|
/// The post status
|
|
Status : string
|
|
|
|
/// Whether this post should be published
|
|
DoPublish : bool
|
|
|
|
/// Names of metadata items
|
|
MetaNames : string[]
|
|
|
|
/// Values of metadata items
|
|
MetaValues : string[]
|
|
|
|
/// Whether to override the published date/time
|
|
SetPublished : bool
|
|
|
|
/// The published date/time to override
|
|
PubOverride : Nullable<DateTime>
|
|
|
|
/// Whether all revisions should be purged and the override date set as the updated date as well
|
|
SetUpdated : bool
|
|
|
|
/// Whether this post has a podcast episode
|
|
IsEpisode : bool
|
|
|
|
/// The URL for the media for this episode (may be permalink)
|
|
Media : string
|
|
|
|
/// The size (in bytes) of the media for this episode
|
|
Length : int64
|
|
|
|
/// The duration of the media for this episode
|
|
Duration : string
|
|
|
|
/// The media type (optional, defaults to podcast-defined media type)
|
|
MediaType : string
|
|
|
|
/// The URL for the image for this episode (may be permalink; optional, defaults to podcast image)
|
|
ImageUrl : string
|
|
|
|
/// A subtitle for the episode (optional)
|
|
Subtitle : string
|
|
|
|
/// The explicit rating for this episode (optional, defaults to podcast setting)
|
|
Explicit : string
|
|
|
|
/// The URL for the chapter file for the episode (may be permalink; optional)
|
|
ChapterFile : string
|
|
|
|
/// The type of the chapter file (optional; defaults to application/json+chapters if chapterFile is provided)
|
|
ChapterType : string
|
|
|
|
/// The URL for the transcript (may be permalink; optional)
|
|
TranscriptUrl : string
|
|
|
|
/// The MIME type for the transcript (optional, recommended if transcriptUrl is provided)
|
|
TranscriptType : string
|
|
|
|
/// The language of the transcript (optional)
|
|
TranscriptLang : string
|
|
|
|
/// Whether the provided transcript should be presented as captions
|
|
TranscriptCaptions : bool
|
|
|
|
/// The season number (optional)
|
|
SeasonNumber : int
|
|
|
|
/// A description of this season (optional, ignored if season number is not provided)
|
|
SeasonDescription : string
|
|
|
|
/// The episode number (decimal; optional)
|
|
EpisodeNumber : string
|
|
|
|
/// A description of this episode (optional, ignored if episode number is not provided)
|
|
EpisodeDescription : string
|
|
}
|
|
|
|
/// Create an edit model from an existing past
|
|
static member fromPost webLog (post : Post) =
|
|
let latest =
|
|
match post.Revisions |> List.sortByDescending (fun r -> r.AsOf) |> List.tryHead with
|
|
| Some rev -> rev
|
|
| None -> Revision.empty
|
|
let post = if post.Metadata |> List.isEmpty then { post with Metadata = [ MetaItem.empty ] } else post
|
|
let episode = defaultArg post.Episode Episode.empty
|
|
{ PostId = PostId.toString post.Id
|
|
Title = post.Title
|
|
Permalink = Permalink.toString post.Permalink
|
|
Source = MarkupText.sourceType latest.Text
|
|
Text = MarkupText.text latest.Text
|
|
Tags = String.Join (", ", post.Tags)
|
|
Template = defaultArg post.Template ""
|
|
CategoryIds = post.CategoryIds |> List.map CategoryId.toString |> Array.ofList
|
|
Status = PostStatus.toString post.Status
|
|
DoPublish = false
|
|
MetaNames = post.Metadata |> List.map (fun m -> m.Name) |> Array.ofList
|
|
MetaValues = post.Metadata |> List.map (fun m -> m.Value) |> Array.ofList
|
|
SetPublished = false
|
|
PubOverride = post.PublishedOn |> Option.map (WebLog.localTime webLog) |> Option.toNullable
|
|
SetUpdated = false
|
|
IsEpisode = Option.isSome post.Episode
|
|
Media = episode.Media
|
|
Length = episode.Length
|
|
Duration = defaultArg (Episode.formatDuration episode) ""
|
|
MediaType = defaultArg episode.MediaType ""
|
|
ImageUrl = defaultArg episode.ImageUrl ""
|
|
Subtitle = defaultArg episode.Subtitle ""
|
|
Explicit = defaultArg (episode.Explicit |> Option.map ExplicitRating.toString) ""
|
|
ChapterFile = defaultArg episode.ChapterFile ""
|
|
ChapterType = defaultArg episode.ChapterType ""
|
|
TranscriptUrl = defaultArg episode.TranscriptUrl ""
|
|
TranscriptType = defaultArg episode.TranscriptType ""
|
|
TranscriptLang = defaultArg episode.TranscriptLang ""
|
|
TranscriptCaptions = defaultArg episode.TranscriptCaptions false
|
|
SeasonNumber = defaultArg episode.SeasonNumber 0
|
|
SeasonDescription = defaultArg episode.SeasonDescription ""
|
|
EpisodeNumber = defaultArg (episode.EpisodeNumber |> Option.map string) ""
|
|
EpisodeDescription = defaultArg episode.EpisodeDescription ""
|
|
}
|
|
|
|
/// Whether this is a new post
|
|
member this.IsNew = this.PostId = "new"
|
|
|
|
/// Update a post with values from the submitted form
|
|
member this.UpdatePost (post : Post) now =
|
|
let revision = { AsOf = now; Text = MarkupText.parse $"{this.Source}: {this.Text}" }
|
|
// Detect a permalink change, and add the prior one to the prior list
|
|
match Permalink.toString post.Permalink with
|
|
| "" -> post
|
|
| link when link = this.Permalink -> post
|
|
| _ -> { post with PriorPermalinks = post.Permalink :: post.PriorPermalinks }
|
|
|> function
|
|
| post ->
|
|
{ post with
|
|
Title = this.Title
|
|
Permalink = Permalink this.Permalink
|
|
PublishedOn = if this.DoPublish then Some now else post.PublishedOn
|
|
UpdatedOn = now
|
|
Text = MarkupText.toHtml revision.Text
|
|
Tags = this.Tags.Split ","
|
|
|> Seq.ofArray
|
|
|> Seq.map (fun it -> it.Trim().ToLower ())
|
|
|> Seq.filter (fun it -> it <> "")
|
|
|> Seq.sort
|
|
|> List.ofSeq
|
|
Template = match this.Template.Trim () with "" -> None | tmpl -> Some tmpl
|
|
CategoryIds = this.CategoryIds |> Array.map CategoryId |> List.ofArray
|
|
Status = if this.DoPublish then Published else post.Status
|
|
Metadata = Seq.zip this.MetaNames this.MetaValues
|
|
|> Seq.filter (fun it -> fst it > "")
|
|
|> Seq.map (fun it -> { Name = fst it; Value = snd it })
|
|
|> Seq.sortBy (fun it -> $"{it.Name.ToLower ()} {it.Value.ToLower ()}")
|
|
|> List.ofSeq
|
|
Revisions = match post.Revisions |> List.tryHead with
|
|
| Some r when r.Text = revision.Text -> post.Revisions
|
|
| _ -> revision :: post.Revisions
|
|
Episode =
|
|
if this.IsEpisode then
|
|
Some {
|
|
Media = this.Media
|
|
Length = this.Length
|
|
Duration = noneIfBlank this.Duration
|
|
|> Option.map (TimeSpan.Parse >> Duration.FromTimeSpan)
|
|
MediaType = noneIfBlank this.MediaType
|
|
ImageUrl = noneIfBlank this.ImageUrl
|
|
Subtitle = noneIfBlank this.Subtitle
|
|
Explicit = noneIfBlank this.Explicit |> Option.map ExplicitRating.parse
|
|
ChapterFile = noneIfBlank this.ChapterFile
|
|
ChapterType = noneIfBlank this.ChapterType
|
|
TranscriptUrl = noneIfBlank this.TranscriptUrl
|
|
TranscriptType = noneIfBlank this.TranscriptType
|
|
TranscriptLang = noneIfBlank this.TranscriptLang
|
|
TranscriptCaptions = if this.TranscriptCaptions then Some true else None
|
|
SeasonNumber = if this.SeasonNumber = 0 then None else Some this.SeasonNumber
|
|
SeasonDescription = noneIfBlank this.SeasonDescription
|
|
EpisodeNumber = match noneIfBlank this.EpisodeNumber |> Option.map Double.Parse with
|
|
| Some it when it = 0.0 -> None
|
|
| Some it -> Some (double it)
|
|
| None -> None
|
|
EpisodeDescription = noneIfBlank this.EpisodeDescription
|
|
}
|
|
else
|
|
None
|
|
}
|
|
|
|
|
|
/// View model to add/edit a redirect rule
|
|
[<CLIMutable; NoComparison; NoEquality>]
|
|
type EditRedirectRuleModel =
|
|
{ /// The ID (index) of the rule being edited
|
|
RuleId : int
|
|
|
|
/// The "from" side of the rule
|
|
From : string
|
|
|
|
/// The "to" side of the rule
|
|
To : string
|
|
|
|
/// Whether this rule uses a regular expression
|
|
IsRegex : bool
|
|
|
|
/// Whether a new rule should be inserted at the top or appended to the end (ignored for edits)
|
|
InsertAtTop : bool
|
|
}
|
|
|
|
/// Create a model from an existing rule
|
|
static member fromRule idx (rule : RedirectRule) =
|
|
{ RuleId = idx
|
|
From = rule.From
|
|
To = rule.To
|
|
IsRegex = rule.IsRegex
|
|
InsertAtTop = false
|
|
}
|
|
|
|
/// Update a rule with the values from this model
|
|
member this.UpdateRule (rule : RedirectRule) =
|
|
{ rule with
|
|
From = this.From
|
|
To = this.To
|
|
IsRegex = this.IsRegex
|
|
}
|
|
|
|
|
|
/// View model to edit RSS settings
|
|
[<CLIMutable; NoComparison; NoEquality>]
|
|
type EditRssModel =
|
|
{ /// Whether the site feed of posts is enabled
|
|
IsFeedEnabled : bool
|
|
|
|
/// The name of the file generated for the site feed
|
|
FeedName : string
|
|
|
|
/// Override the "posts per page" setting for the site feed
|
|
ItemsInFeed : int
|
|
|
|
/// Whether feeds are enabled for all categories
|
|
IsCategoryEnabled : bool
|
|
|
|
/// Whether feeds are enabled for all tags
|
|
IsTagEnabled : bool
|
|
|
|
/// A copyright string to be placed in all feeds
|
|
Copyright : string
|
|
}
|
|
|
|
/// Create an edit model from a set of RSS options
|
|
static member fromRssOptions (rss : RssOptions) =
|
|
{ IsFeedEnabled = rss.IsFeedEnabled
|
|
FeedName = rss.FeedName
|
|
ItemsInFeed = defaultArg rss.ItemsInFeed 0
|
|
IsCategoryEnabled = rss.IsCategoryEnabled
|
|
IsTagEnabled = rss.IsTagEnabled
|
|
Copyright = defaultArg rss.Copyright ""
|
|
}
|
|
|
|
/// Update RSS options from values in this model
|
|
member this.UpdateOptions (rss : RssOptions) =
|
|
{ rss with
|
|
IsFeedEnabled = this.IsFeedEnabled
|
|
FeedName = this.FeedName
|
|
ItemsInFeed = if this.ItemsInFeed = 0 then None else Some this.ItemsInFeed
|
|
IsCategoryEnabled = this.IsCategoryEnabled
|
|
IsTagEnabled = this.IsTagEnabled
|
|
Copyright = noneIfBlank this.Copyright
|
|
}
|
|
|
|
|
|
/// View model to edit a tag mapping
|
|
[<CLIMutable; NoComparison; NoEquality>]
|
|
type EditTagMapModel =
|
|
{ /// The ID of the tag mapping being edited
|
|
Id : string
|
|
|
|
/// The tag being mapped to a different link value
|
|
Tag : string
|
|
|
|
/// The link value for the tag
|
|
UrlValue : string
|
|
}
|
|
|
|
/// Whether this is a new tag mapping
|
|
member this.IsNew = this.Id = "new"
|
|
|
|
/// Create an edit model from the tag mapping
|
|
static member fromMapping (tagMap : TagMap) : EditTagMapModel =
|
|
{ Id = TagMapId.toString tagMap.Id
|
|
Tag = tagMap.Tag
|
|
UrlValue = tagMap.UrlValue
|
|
}
|
|
|
|
|
|
/// View model to display a user's information
|
|
[<CLIMutable; NoComparison; NoEquality>]
|
|
type EditUserModel =
|
|
{ /// The ID of the user
|
|
Id : string
|
|
|
|
/// The user's access level
|
|
AccessLevel : string
|
|
|
|
/// The user name (e-mail address)
|
|
Email : string
|
|
|
|
/// The URL of the user's personal site
|
|
Url : string
|
|
|
|
/// The user's first name
|
|
FirstName : string
|
|
|
|
/// The user's last name
|
|
LastName : string
|
|
|
|
/// The user's preferred name
|
|
PreferredName : string
|
|
|
|
/// The user's password
|
|
Password : string
|
|
|
|
/// Confirmation of the user's password
|
|
PasswordConfirm : string
|
|
}
|
|
|
|
/// Construct a displayed user from a web log user
|
|
static member fromUser (user : WebLogUser) =
|
|
{ Id = WebLogUserId.toString user.Id
|
|
AccessLevel = AccessLevel.toString user.AccessLevel
|
|
Url = defaultArg user.Url ""
|
|
Email = user.Email
|
|
FirstName = user.FirstName
|
|
LastName = user.LastName
|
|
PreferredName = user.PreferredName
|
|
Password = ""
|
|
PasswordConfirm = ""
|
|
}
|
|
|
|
/// Is this a new user?
|
|
member this.IsNew = this.Id = "new"
|
|
|
|
/// Update a user with values from this model (excludes password)
|
|
member this.UpdateUser (user : WebLogUser) =
|
|
{ user with
|
|
AccessLevel = AccessLevel.parse this.AccessLevel
|
|
Email = this.Email
|
|
Url = noneIfBlank this.Url
|
|
FirstName = this.FirstName
|
|
LastName = this.LastName
|
|
PreferredName = this.PreferredName
|
|
}
|
|
|
|
|
|
/// The model to use to allow a user to log on
|
|
[<CLIMutable; NoComparison; NoEquality>]
|
|
type LogOnModel =
|
|
{ /// The user's e-mail address
|
|
EmailAddress : string
|
|
|
|
/// The user's password
|
|
Password : string
|
|
|
|
/// Where the user should be redirected once they have logged on
|
|
ReturnTo : string option
|
|
}
|
|
|
|
/// An empty log on model
|
|
static member empty =
|
|
{ EmailAddress = ""; Password = ""; ReturnTo = None }
|
|
|
|
|
|
/// View model to manage permalinks
|
|
[<CLIMutable; NoComparison; NoEquality>]
|
|
type ManagePermalinksModel =
|
|
{ /// The ID for the entity being edited
|
|
Id : string
|
|
|
|
/// The type of entity being edited ("page" or "post")
|
|
Entity : string
|
|
|
|
/// The current title of the page or post
|
|
CurrentTitle : string
|
|
|
|
/// The current permalink of the page or post
|
|
CurrentPermalink : string
|
|
|
|
/// The prior permalinks for the page or post
|
|
Prior : string[]
|
|
}
|
|
|
|
/// Create a permalink model from a page
|
|
static member fromPage (pg : Page) =
|
|
{ Id = PageId.toString pg.Id
|
|
Entity = "page"
|
|
CurrentTitle = pg.Title
|
|
CurrentPermalink = Permalink.toString pg.Permalink
|
|
Prior = pg.PriorPermalinks |> List.map Permalink.toString |> Array.ofList
|
|
}
|
|
|
|
/// Create a permalink model from a post
|
|
static member fromPost (post : Post) =
|
|
{ Id = PostId.toString post.Id
|
|
Entity = "post"
|
|
CurrentTitle = post.Title
|
|
CurrentPermalink = Permalink.toString post.Permalink
|
|
Prior = post.PriorPermalinks |> List.map Permalink.toString |> Array.ofList
|
|
}
|
|
|
|
|
|
/// View model to manage revisions
|
|
[<NoComparison; NoEquality>]
|
|
type ManageRevisionsModel =
|
|
{ /// The ID for the entity being edited
|
|
Id : string
|
|
|
|
/// The type of entity being edited ("page" or "post")
|
|
Entity : string
|
|
|
|
/// The current title of the page or post
|
|
CurrentTitle : string
|
|
|
|
/// The revisions for the page or post
|
|
Revisions : DisplayRevision[]
|
|
}
|
|
|
|
/// Create a revision model from a page
|
|
static member fromPage webLog (pg : Page) =
|
|
{ Id = PageId.toString pg.Id
|
|
Entity = "page"
|
|
CurrentTitle = pg.Title
|
|
Revisions = pg.Revisions |> List.map (DisplayRevision.fromRevision webLog) |> Array.ofList
|
|
}
|
|
|
|
/// Create a revision model from a post
|
|
static member fromPost webLog (post : Post) =
|
|
{ Id = PostId.toString post.Id
|
|
Entity = "post"
|
|
CurrentTitle = post.Title
|
|
Revisions = post.Revisions |> List.map (DisplayRevision.fromRevision webLog) |> Array.ofList
|
|
}
|
|
|
|
|
|
/// View model for posts in a list
|
|
[<NoComparison; NoEquality>]
|
|
type PostListItem =
|
|
{ /// The ID of the post
|
|
Id : string
|
|
|
|
/// The ID of the user who authored the post
|
|
AuthorId : string
|
|
|
|
/// The status of the post
|
|
Status : string
|
|
|
|
/// The title of the post
|
|
Title : string
|
|
|
|
/// The permalink for the post
|
|
Permalink : string
|
|
|
|
/// When this post was published
|
|
PublishedOn : Nullable<DateTime>
|
|
|
|
/// When this post was last updated
|
|
UpdatedOn : DateTime
|
|
|
|
/// The text of the post
|
|
Text : string
|
|
|
|
/// The IDs of the categories for this post
|
|
CategoryIds : string list
|
|
|
|
/// Tags for the post
|
|
Tags : string list
|
|
|
|
/// The podcast episode information for this post
|
|
Episode : Episode option
|
|
|
|
/// Metadata for the post
|
|
Metadata : MetaItem list
|
|
}
|
|
|
|
/// Create a post list item from a post
|
|
static member fromPost (webLog : WebLog) (post : Post) =
|
|
let _, extra = WebLog.hostAndPath webLog
|
|
let inTZ = WebLog.localTime webLog
|
|
{ Id = PostId.toString post.Id
|
|
AuthorId = WebLogUserId.toString post.AuthorId
|
|
Status = PostStatus.toString post.Status
|
|
Title = post.Title
|
|
Permalink = Permalink.toString post.Permalink
|
|
PublishedOn = post.PublishedOn |> Option.map inTZ |> Option.toNullable
|
|
UpdatedOn = inTZ post.UpdatedOn
|
|
Text = addBaseToRelativeUrls extra post.Text
|
|
CategoryIds = post.CategoryIds |> List.map CategoryId.toString
|
|
Tags = post.Tags
|
|
Episode = post.Episode
|
|
Metadata = post.Metadata
|
|
}
|
|
|
|
|
|
/// View model for displaying posts
|
|
type PostDisplay =
|
|
{ /// The posts to be displayed
|
|
Posts : PostListItem[]
|
|
|
|
/// Author ID -> name lookup
|
|
Authors : MetaItem list
|
|
|
|
/// A subtitle for the page
|
|
Subtitle : string option
|
|
|
|
/// The link to view newer (more recent) posts
|
|
NewerLink : string option
|
|
|
|
/// The name of the next newer post (single-post only)
|
|
NewerName : string option
|
|
|
|
/// The link to view older (less recent) posts
|
|
OlderLink : string option
|
|
|
|
/// The name of the next older post (single-post only)
|
|
OlderName : string option
|
|
}
|
|
|
|
|
|
/// View model for editing web log settings
|
|
[<CLIMutable; NoComparison; NoEquality>]
|
|
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
|
|
|
|
/// The default page
|
|
DefaultPage : string
|
|
|
|
/// How many posts should appear on index pages
|
|
PostsPerPage : int
|
|
|
|
/// The time zone in which dates/times should be displayed
|
|
TimeZone : string
|
|
|
|
/// The theme to use to display the web log
|
|
ThemeId : string
|
|
|
|
/// 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
|
|
ThemeId = ThemeId.toString webLog.ThemeId
|
|
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
|
|
ThemeId = ThemeId this.ThemeId
|
|
AutoHtmx = this.AutoHtmx
|
|
Uploads = UploadDestination.parse this.Uploads
|
|
}
|
|
|
|
|
|
/// View model for uploading a file
|
|
[<CLIMutable; NoComparison; NoEquality>]
|
|
type UploadFileModel =
|
|
{ /// The upload destination
|
|
Destination : string
|
|
}
|
|
|
|
|
|
/// View model for uploading a theme
|
|
[<CLIMutable; NoComparison; NoEquality>]
|
|
type UploadThemeModel =
|
|
{ /// Whether the uploaded theme should overwrite an existing theme
|
|
DoOverwrite : bool
|
|
}
|
|
|
|
|
|
/// A message displayed to the user
|
|
[<CLIMutable; NoComparison; NoEquality>]
|
|
type UserMessage =
|
|
{ /// The level of the message
|
|
Level : string
|
|
|
|
/// The message
|
|
Message : string
|
|
|
|
/// Further details about the message
|
|
Detail : string option
|
|
}
|
|
|
|
/// Functions to support user messages
|
|
module UserMessage =
|
|
|
|
/// An empty user message (use one of the others for pre-filled level)
|
|
let empty = { Level = ""; Message = ""; Detail = None }
|
|
|
|
/// A blank success message
|
|
let success = { empty with Level = "success" }
|
|
|
|
/// A blank informational message
|
|
let info = { empty with Level = "primary" }
|
|
|
|
/// A blank warning message
|
|
let warning = { empty with Level = "warning" }
|
|
|
|
/// A blank error message
|
|
let error = { empty with Level = "danger" }
|