myWebLog/src/MyWebLog.Domain/ViewModels.fs

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
}

/// Support functions for custom feed displays
module DisplayCustomFeed =
    
    /// Create a display version from a custom feed
    let fromFeed (cats: DisplayCategory array) (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        = string feed.Id
            Source    = source
            Path      = string 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
} with
    
    /// Create a minimal display page (no text or metadata) from a database page
    static member FromPageMinimal (webLog: WebLog) (page: Page) = {
        Id           = string page.Id
        AuthorId     = string page.AuthorId
        Title        = page.Title
        Permalink    = string page.Permalink
        PublishedOn  = webLog.LocalTime page.PublishedOn
        UpdatedOn    = webLog.LocalTime page.UpdatedOn
        IsInPageList = page.IsInPageList
        IsDefault    = string page.Id = webLog.DefaultPage
        Text         = ""
        Metadata     = []
    }
    
    /// Create a display page from a database page
    static member FromPage webLog page =
        { DisplayPage.FromPageMinimal webLog page with
            Text     = addBaseToRelativeUrls webLog.ExtraPath 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
}

/// Functions to support displaying revisions
module DisplayRevision =
    
    /// Create a display revision from an actual revision
    let fromRevision (webLog: WebLog) (rev : Revision) =
        {   AsOf      = rev.AsOf.ToDateTimeUtc ()
            AsOfLocal = webLog.LocalTime rev.AsOf
            Format    = rev.Text.SourceType
        }


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
}

/// Functions to support displaying themes
module DisplayTheme =
    
    /// Create a display theme from a theme
    let fromTheme inUseFunc (theme: Theme) =
        {   Id            = string theme.Id
            Name          = theme.Name
            Version       = theme.Version
            TemplateCount = List.length theme.Templates
            IsInUse       = inUseFunc theme.Id
            IsOnDisk      = File.Exists $"{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
}

/// Functions to support displaying uploads
module DisplayUpload =
    
    /// Create a display uploaded file
    let fromUpload (webLog: WebLog) (source: UploadDestination) (upload: Upload) =
        let path = string upload.Path
        let name = Path.GetFileName path
        {   Id        = string upload.Id
            Name      = name
            Path      = path.Replace(name, "")
            UpdatedOn = Some (webLog.LocalTime upload.UpdatedOn)
            Source    = string 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>
}

/// Functions to support displaying a user's information
module DisplayUser =
    
    /// Construct a displayed user from a web log user
    let fromUser (webLog: WebLog) (user: WebLogUser) = {
        Id            = string user.Id
        Email         = user.Email
        FirstName     = user.FirstName
        LastName      = user.LastName
        PreferredName = user.PreferredName
        Url           = defaultArg user.Url ""
        AccessLevel   = string user.AccessLevel
        CreatedOn     = webLog.LocalTime user.CreatedOn
        LastSeenOn    = user.LastSeenOn |> Option.map webLog.LocalTime |> 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
} with
    
    /// Create an edit model from an existing category 
    static member fromCategory (cat: Category) =
        {   CategoryId  = string cat.Id
            Name        = cat.Name
            Slug        = cat.Slug
            Description = defaultArg cat.Description ""
            ParentId    = cat.ParentId |> Option.map string |> 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          = string feed.Id
                SourceType  = match feed.Source with Category _ -> "category" | Tag _ -> "tag"
                SourceValue = match feed.Source with Category (CategoryId catId) -> catId | Tag tag -> tag
                Path        = string 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         = string p.ImageUrl
                AppleCategory    = p.AppleCategory
                AppleSubcategory = defaultArg p.AppleSubcategory ""
                Explicit         = string p.Explicit
                DefaultMediaType = defaultArg p.DefaultMediaType ""
                MediaBaseUrl     = defaultArg p.MediaBaseUrl ""
                FundingUrl       = defaultArg p.FundingUrl ""
                FundingText      = defaultArg p.FundingText ""
                PodcastGuid      = p.PodcastGuid |> Option.map _.ToString().ToLowerInvariant() |> Option.defaultValue ""
                Medium           = p.Medium |> Option.map string |> 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 array
    
    /// Values of metadata items
    MetaValues: string array
} with
    
    /// Create an edit model from an existing page
    static member fromPage (page: Page) =
        let latest =
            match page.Revisions |> List.sortByDescending _.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            = string page.Id
            Title             = page.Title
            Permalink         = string page.Permalink
            Template          = defaultArg page.Template ""
            IsShownInPageList = page.IsInPageList
            Source            = latest.Text.SourceType
            Text              = latest.Text.Text
            MetaNames         = page.Metadata |> List.map _.Name  |> Array.ofList
            MetaValues        = page.Metadata |> List.map _.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 string 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         = revision.Text.AsHtml()
                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 array
    
    /// The post status
    Status: string
    
    /// Whether this post should be published
    DoPublish: bool
    
    /// Names of metadata items
    MetaNames: string array
    
    /// Values of metadata items
    MetaValues: string array
    
    /// 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
} with
    
    /// Create an edit model from an existing past
    static member fromPost (webLog: WebLog) (post: Post) =
        let latest =
            match post.Revisions |> List.sortByDescending _.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             = string post.Id
            Title              = post.Title
            Permalink          = string post.Permalink
            Source             = latest.Text.SourceType
            Text               = latest.Text.Text
            Tags               = String.Join (", ", post.Tags)
            Template           = defaultArg post.Template ""
            CategoryIds        = post.CategoryIds |> List.map string |> Array.ofList
            Status             = string post.Status
            DoPublish          = false
            MetaNames          = post.Metadata |> List.map _.Name  |> Array.ofList
            MetaValues         = post.Metadata |> List.map _.Value |> Array.ofList
            SetPublished       = false
            PubOverride        = post.PublishedOn |> Option.map webLog.LocalTime |> Option.toNullable
            SetUpdated         = false
            IsEpisode          = Option.isSome post.Episode
            Media              = episode.Media
            Length             = episode.Length
            Duration           = defaultArg (episode.FormatDuration()) ""
            MediaType          = defaultArg episode.MediaType ""
            ImageUrl           = defaultArg episode.ImageUrl ""
            Subtitle           = defaultArg episode.Subtitle ""
            Explicit           = defaultArg (episode.Explicit |> Option.map string) ""
            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 string 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        = revision.Text.AsHtml()
                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
                            Chapters           = match post.Episode with Some e -> e.Chapters | None -> None
                            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       = string 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
} with
    
    /// Construct a displayed user from a web log user
    static member fromUser (user: WebLogUser) =
        {   Id              = string user.Id
            AccessLevel     = string 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 array
} with
    
    /// Create a permalink model from a page
    static member fromPage (pg: Page) =
        {   Id               = string pg.Id
            Entity           = "page"
            CurrentTitle     = pg.Title
            CurrentPermalink = string pg.Permalink
            Prior            = pg.PriorPermalinks |> List.map string |> Array.ofList
        }

    /// Create a permalink model from a post
    static member fromPost (post: Post) =
        {   Id               = string post.Id
            Entity           = "post"
            CurrentTitle     = post.Title
            CurrentPermalink = string post.Permalink
            Prior            = post.PriorPermalinks |> List.map string |> 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 array
    }
    
    /// Create a revision model from a page
    static member fromPage webLog (pg: Page) =
        {   Id           = string 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           = string 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
} with

    /// Create a post list item from a post
    static member fromPost (webLog: WebLog) (post: Post) = {
        Id          = string post.Id
        AuthorId    = string post.AuthorId
        Status      = string post.Status
        Title       = post.Title
        Permalink   = string post.Permalink
        PublishedOn = post.PublishedOn |> Option.map webLog.LocalTime |> Option.toNullable
        UpdatedOn   = webLog.LocalTime post.UpdatedOn
        Text        = addBaseToRelativeUrls webLog.ExtraPath post.Text
        CategoryIds = post.CategoryIds |> List.map string
        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
} with
    
    /// 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      = string webLog.ThemeId
            AutoHtmx     = webLog.AutoHtmx
            Uploads      = string 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" }