Program.cs

usingFluentValidation;
usingFluentValidation.AspNetCore;
usingGanss.Xss;
usingHtmlBuilders;
usingLiteDB;
usingMarkdig;
usingMicrosoft.AspNetCore.Antiforgery;
usingMicrosoft.AspNetCore.Html;
usingMicrosoft.AspNetCore.Mvc.ModelBinding;
usingMicrosoft.Extensions.Caching.Memory;
usingMicrosoft.Extensions.Primitives;
usingScriban;
usingSystem.Globalization;
usingSystem.Text.RegularExpressions;
usingstaticHtmlBuilders.HtmlTags;

conststringDisplayDateFormat="MMMM dd, yyyy";
conststringHomePageName="home-page";
conststringHtmlMime="text/html";

varbuilder=WebApplication.CreateBuilder();
builder.Services
.AddSingleton<Wiki>()
.AddSingleton<Render>()
.AddAntiforgery()
.AddMemoryCache();

builder.Logging.AddConsole().SetMinimumLevel(LogLevel.Warning);

varapp=builder.Build();

// Load home page
app.MapGet("/",(Wikiwiki,Renderrender)=>
{
Page?page=wiki.GetPage(HomePageName);

if(pageis not object)
returnResults.Redirect($"/{HomePageName}");

returnResults.Text(render.BuildPage(HomePageName,atBody:()=>
new[]
{
RenderPageContent(page),
RenderPageAttachments(page),
A.Href($"/edit?pageName={HomePageName}").Class("uk-button uk-button-default uk-button-small").Append("Edit").ToHtmlString()
},
atSidePanel:()=>AllPages(wiki)
).ToString(),HtmlMime);
});

app.MapGet("/new-page",(string?pageName)=>
{
if(string.IsNullOrEmpty(pageName))
Results.Redirect("/");

// Copied from https://www.30secondsofcode.org/c-sharp/s/to-kebab-case
stringToKebabCase(stringstr)
{
Regexpattern=newRegex(@"[A-Z]{2,}(?=[A-Z][a-z]+[0-9]*|\b)|[A-Z]?[a-z]+[0-9]*|[A-Z]|[0-9]+");
returnstring.Join("-",pattern.Matches(str)).ToLower();
}

varpage=ToKebabCase(pageName!);
returnResults.Redirect($"/{page}");
});

// Edit a wiki page
app.MapGet("/edit",(stringpageName,HttpContextcontext,Wikiwiki,Renderrender,IAntiforgeryantiForgery)=>
{
Page?page=wiki.GetPage(pageName);
if(pageis not object)
returnResults.NotFound();

returnResults.Text(render.BuildEditorPage(pageName,
atBody:()=>
new[]
{
BuildForm(newPageInput(page!.Id,pageName,page.Content,null),path:$"{pageName}",antiForgery:antiForgery.GetAndStoreTokens(context)),
RenderPageAttachmentsForEdit(page!,antiForgery.GetAndStoreTokens(context))
},
atSidePanel:()=>
{
varlist=newList<string>();
// Do not show delete button on home page
if(!pageName!.ToString().Equals(HomePageName,StringComparison.Ordinal))
list.Add(RenderDeletePageButton(page!,antiForgery:antiForgery.GetAndStoreTokens(context)));

list.Add(Br.ToHtmlString());
list.AddRange(AllPagesForEditing(wiki));
returnlist;
}).ToString(),HtmlMime);
});

// Deal with attachment download
app.MapGet("/attachment",(stringfileId,Wikiwiki)=>
{
varfile=wiki.GetFile(fileId);
if(fileis not object)
returnResults.NotFound();

app!.Logger.LogInformation("Attachment "+file.Value.meta.Id+" - "+file.Value.meta.Filename);

returnResults.File(file.Value.file,file.Value.meta.MimeType);
});

// Load a wiki page
app.MapGet("/{pageName}",(stringpageName,HttpContextcontext,Wikiwiki,Renderrender,IAntiforgeryantiForgery)=>
{
pageName=pageName??"";

Page?page=wiki.GetPage(pageName);

if(pageisobject)
{
returnResults.Text(render.BuildPage(pageName,atBody:()=>
new[]
{
RenderPageContent(page),
RenderPageAttachments(page),
Div.Class("last-modified").Append("Last modified: "+page!.LastModifiedUtc.ToString(DisplayDateFormat)).ToHtmlString(),
A.Href($"/edit?pageName={pageName}").Append("Edit").ToHtmlString()
},
atSidePanel:()=>AllPages(wiki)
).ToString(),HtmlMime);
}
else
{
returnResults.Text(render.BuildEditorPage(pageName,
atBody:()=>
new[]
{
BuildForm(newPageInput(null,pageName,string.Empty,null),path:pageName,antiForgery:antiForgery.GetAndStoreTokens(context))
},
atSidePanel:()=>AllPagesForEditing(wiki)).ToString(),HtmlMime);
}
});

// Delete a page
app.MapPost("/delete-page",async(HttpContextcontext,IAntiforgeryantiForgery,Wikiwiki)=>
{
awaitantiForgery.ValidateRequestAsync(context);
varid=context.Request.Form["Id"];

if(StringValues.IsNullOrEmpty(id))
{
app.Logger.LogWarning($"Unable to delete page because form Id is missing");
returnResults.Redirect("/");
}

var(isOk,exception)=wiki.DeletePage(Convert.ToInt32(id),HomePageName);

if(!isOk&&exceptionisobject)
app.Logger.LogError(exception,$"Error in deleting page id {id}");
elseif(!isOk)
app.Logger.LogError($"Unable to delete page id {id}");

returnResults.Redirect("/");
});

app.MapPost("/delete-attachment",async(HttpContextcontext,IAntiforgeryantiForgery,Wikiwiki)=>
{
awaitantiForgery.ValidateRequestAsync(context);
varid=context.Request.Form["Id"];

if(StringValues.IsNullOrEmpty(id))
{
app.Logger.LogWarning($"Unable to delete attachment because form Id is missing");
returnResults.Redirect("/");
}

varpageId=context.Request.Form["PageId"];
if(StringValues.IsNullOrEmpty(pageId))
{
app.Logger.LogWarning($"Unable to delete attachment because form PageId is missing");
returnResults.Redirect("/");
}

var(isOk,page,exception)=wiki.DeleteAttachment(Convert.ToInt32(pageId),id.ToString());

if(!isOk)
{
if(exceptionisobject)
app.Logger.LogError(exception,$"Error in deleting page attachment id {id}");
else
app.Logger.LogError($"Unable to delete page attachment id {id}");

if(pageisobject)
returnResults.Redirect($"/{page.Name}");
else
returnResults.Redirect("/");
}

returnResults.Redirect($"/{page!.Name}");
});

// Add or update a wiki page
app.MapPost("/{pageName}",async(HttpContextcontext,Wikiwiki,Renderrender,IAntiforgeryantiForgery)=>
{
varpageName=context.Request.RouteValues["pageName"]asstring??"";
awaitantiForgery.ValidateRequestAsync(context);

PageInputinput=PageInput.From(context.Request.Form);

varmodelState=newModelStateDictionary();
varvalidator=newPageInputValidator(pageName,HomePageName);
validator.Validate(input).AddToModelState(modelState,null);

if(!modelState.IsValid)
{
returnResults.Text(render.BuildEditorPage(pageName,
atBody:()=>
new[]
{
BuildForm(input,path:$"{pageName}",antiForgery:antiForgery.GetAndStoreTokens(context),modelState)
},
atSidePanel:()=>AllPages(wiki)).ToString(),HtmlMime);
}

var(isOk,p,ex)=wiki.SavePage(input);
if(!isOk)
{
app.Logger.LogError(ex,"Problem in saving page");
returnResults.Problem("Progblem in saving page");
}

returnResults.Redirect($"/{p!.Name}");
});

awaitapp.RunAsync();

// End of the web part

staticstring[]AllPages(Wikiwiki)=>new[]
{
@"<span class=""uk-label"">Pages</span>",
@"<ul class=""uk-list"">",
string.Join("",
wiki.ListAllPages().OrderBy(x =>x.Name)
.Select(x =>Li.Append(A.Href(x.Name).Append(x.Name)).ToHtmlString()
)
),
"</ul>"
};

staticstring[]AllPagesForEditing(Wikiwiki)
{
staticstringKebabToNormalCase(stringtxt)=>CultureInfo.CurrentCulture.TextInfo.ToTitleCase(txt.Replace('-',' '));

returnnew[]
{
@"<span class=""uk-label"">Pages</span>",
@"<ul class=""uk-list"">",
string.Join("",
wiki.ListAllPages().OrderBy(x =>x.Name)
.Select(x =>Li.Append(Div.Class("uk-inline")
.Append(Span.Class("uk-form-icon").Attribute("uk-icon","icon: copy"))
.Append(Input.Text.Value($"[{KebabToNormalCase(x.Name)}](/{x.Name})").Class("uk-input uk-form-small").Style("cursor","pointer").Attribute("onclick","copyMarkdownLink(this);"))
).ToHtmlString()
)
),
"</ul>"
};
}

staticstringRenderMarkdown(stringstr)
{
varsanitizer=newHtmlSanitizer();
returnsanitizer.Sanitize(Markdown.ToHtml(str,newMarkdownPipelineBuilder().UseSoftlineBreakAsHardlineBreak().UseAdvancedExtensions().Build()));
}

staticstringRenderPageContent(Pagepage)=>RenderMarkdown(page.Content);

staticstringRenderDeletePageButton(Pagepage,AntiforgeryTokenSetantiForgery)
{
varantiForgeryField=Input.Hidden.Name(antiForgery.FormFieldName).Value(antiForgery.RequestToken!);
HtmlTagid=Input.Hidden.Name("Id").Value(page.Id.ToString());
varsubmit=Div.Style("margin-top","20px").Append(Button.Class("uk-button uk-button-danger").Append("Delete Page"));

varform=Form
.Attribute("method","post")
.Attribute("action",$"/delete-page")
.Attribute("onsubmit",$"return confirm('Please confirm to delete this page');")
.Append(antiForgeryField)
.Append(id)
.Append(submit);

returnform.ToHtmlString();
}

staticstringRenderPageAttachmentsForEdit(Pagepage,AntiforgeryTokenSetantiForgery)
{
if(page.Attachments.Count==0)
returnstring.Empty;

varlabel=Span.Class("uk-label").Append("Attachments");
varlist=Ul.Class("uk-list");

HtmlTagCreateEditorHelper(Attachmentattachment)=>
Span.Class("uk-inline")
.Append(Span.Class("uk-form-icon").Attribute("uk-icon","icon: copy"))
.Append(Input.Text.Value($"[{attachment.FileName}](/attachment?fileId={attachment.FileId})")
.Class("uk-input uk-form-small uk-form-width-large")
.Style("cursor","pointer")
.Attribute("onclick","copyMarkdownLink(this);")
);

staticHtmlTagCreateDelete(intpageId,stringattachmentId,AntiforgeryTokenSetantiForgery)
{
varantiForgeryField=Input.Hidden.Name(antiForgery.FormFieldName).Value(antiForgery.RequestToken!);
varid=Input.Hidden.Name("Id").Value(attachmentId.ToString());
varname=Input.Hidden.Name("PageId").Value(pageId.ToString());

varsubmit=Button.Class("uk-button uk-button-danger uk-button-small").Append(Span.Attribute("uk-icon","icon: close; ratio: .75;"));
varform=Form
.Style("display","inline")
.Attribute("method","post")
.Attribute("action",$"/delete-attachment")
.Attribute("onsubmit",$"return confirm('Please confirm to delete this attachment');")
.Append(antiForgeryField)
.Append(id)
.Append(name)
.Append(submit);

returnform;
}

foreach(varattachmentinpage.Attachments)
{
list=list.Append(Li
.Append(CreateEditorHelper(attachment))
.Append(CreateDelete(page.Id,attachment.FileId,antiForgery))
);
}
returnlabel.ToHtmlString()+list.ToHtmlString();
}

staticstringRenderPageAttachments(Pagepage)
{
if(page.Attachments.Count==0)
returnstring.Empty;

varlabel=Span.Class("uk-label").Append("Attachments");
varlist=Ul.Class("uk-list uk-list-disc");
foreach(varattachmentinpage.Attachments)
{
list=list.Append(Li.Append(A.Href($"/attachment?fileId={attachment.FileId}").Append(attachment.FileName)));
}
returnlabel.ToHtmlString()+list.ToHtmlString();
}

// Build the wiki input form 
staticstringBuildForm(PageInputinput,stringpath,AntiforgeryTokenSetantiForgery,ModelStateDictionary?modelState=null)
{
boolIsFieldOK(stringkey)=>modelState!.ContainsKey(key)&&modelState[key]!.ValidationState==ModelValidationState.Invalid;

varantiForgeryField=Input.Hidden.Name(antiForgery.FormFieldName).Value(antiForgery.RequestToken!);

varnameField=Div
.Append(Label.Class("uk-form-label").Append(nameof(input.Name)))
.Append(Div.Class("uk-form-controls")
.Append(Input.Text.Class("uk-input").Name("Name").Value(input.Name))
);

varcontentField=Div
.Append(Label.Class("uk-form-label").Append(nameof(input.Content)))
.Append(Div.Class("uk-form-controls")
.Append(Textarea.Name("Content").Class("uk-textarea").Append(input.Content))
);

varattachmentField=Div
.Append(Label.Class("uk-form-label").Append(nameof(input.Attachment)))
.Append(Div.Attribute("uk-form-custom","target: true")
.Append(Input.File.Name("Attachment"))
.Append(Input.Text.Class("uk-input uk-form-width-large").Attribute("placeholder","Click to select file").ToggleAttribute("disabled",true))
);

if(modelStateisobject&&!modelState.IsValid)
{
if(IsFieldOK("Name"))
{
foreach(varerinmodelState["Name"]!.Errors)
{
nameField=nameField.Append(Div.Class("uk-form-danger uk-text-small").Append(er.ErrorMessage));
}
}

if(IsFieldOK("Content"))
{
foreach(varerinmodelState["Content"]!.Errors)
{
contentField=contentField.Append(Div.Class("uk-form-danger uk-text-small").Append(er.ErrorMessage));
}
}
}

varsubmit=Div.Style("margin-top","20px").Append(Button.Class("uk-button uk-button-primary").Append("Submit"));

varform=Form
.Class("uk-form-stacked")
.Attribute("method","post")
.Attribute("enctype","multipart/form-data")
.Attribute("action",$"/{path}")
.Append(antiForgeryField)
.Append(nameField)
.Append(contentField)
.Append(attachmentField);

if(input.Idisobject)
{
HtmlTagid=Input.Hidden.Name("Id").Value(input.Id.ToString()!);
form=form.Append(id);
}

form=form.Append(submit);

returnform.ToHtmlString();
}

classRender
{
staticstringKebabToNormalCase(stringtxt)=>CultureInfo.CurrentCulture.TextInfo.ToTitleCase(txt.Replace('-',' '));

staticstring[]MarkdownEditorHead()=>new[]
{
@"<link rel=""stylesheet"" href=""https://unpkg.com/easymde/dist/easymde.min.css"">",
@"<script src=""https://unpkg.com/easymde/dist/easymde.min.js""></script>"
};

staticstring[]MarkdownEditorFoot()=>new[]
{
@"<script>
 var easyMDE = new EasyMDE({
 insertTexts: {
 link: [""["", ""]()""]
 }
 });

 function copyMarkdownLink(element) {
 element.select();
 document.execCommand(""copy"");
 }
 </script>"
};

(Templatehead,Templatebody,Templatelayout)_templates=(
head:Scriban.Template.Parse(
"""
 <meta charset="utf-8">
 <meta name="viewport" content="width=device-width, initial-scale=1">
 <title>{{ title }}</title>
 <link rel="stylesheet" href="https://cdn.jsdelivr.net/npm/uikit@3.19.4/dist/css/uikit.min.css" />
 {{ header }}
 <style>
 .last-modified { font-size: small; }
 a:visited { color: blue; }
 a:link { color: red; }
 </style>
 """),
body:Scriban.Template.Parse("""
 <nav class="uk-navbar-container">
 <div class="uk-container">
 <div class="uk-navbar">
 <div class="uk-navbar-left">
 <ul class="uk-navbar-nav">
 <li class="uk-active"><a href="/"><span uk-icon="home"></span></a></li>
 </ul>
 </div>
 <div class="uk-navbar-center">
 <div class="uk-navbar-item">
 <form action="/new-page">
 <input class="uk-input uk-form-width-large" type="text" name="pageName" placeholder="Type desired page title here"></input>
 <input type="submit" class="uk-button uk-button-default" value="Add New Page">
 </form>
 </div>
 </div>
 </div>
 </div>
 </nav>
 {{ if at_side_panel != "" }}
 <div class="uk-container">
 <div uk-grid>
 <div class="uk-width-4-5">
 <h1>{{ page_name }}</h1>
 {{ content }}
 </div>
 <div class="uk-width-1-5">
 {{ at_side_panel }}
 </div>
 </div>
 </div>
 {{ else }}
 <div class="uk-container">
 <h1>{{ page_name }}</h1>
 {{ content }}
 </div>
 {{ end }}

 <script src="https://cdn.jsdelivr.net/npm/uikit@3.19.4/dist/js/uikit.min.js"></script>
 <script src="https://cdn.jsdelivr.net/npm/uikit@3.19.4/dist/js/uikit-icons.min.js"></script>
 {{ at_foot }}

 """),
layout:Scriban.Template.Parse("""
 <!DOCTYPE html>
 <head>
 {{ head }}
 </head>
 <body>
 {{ body }}
 </body>
 </html>
 """)
);

// Use only when the page requires editor
publicHtmlStringBuildEditorPage(stringtitle,Func<IEnumerable<string>>atBody,Func<IEnumerable<string>>?atSidePanel=null)=>
BuildPage(
title,
atHead:()=>MarkdownEditorHead(),
atBody:atBody,
atSidePanel:atSidePanel,
atFoot:()=>MarkdownEditorFoot()
);

// General page layout building function
publicHtmlStringBuildPage(stringtitle,Func<IEnumerable<string>>?atHead=null,Func<IEnumerable<string>>?atBody=null,Func<IEnumerable<string>>?atSidePanel=null,Func<IEnumerable<string>>?atFoot=null)
{
varhead=_templates.head.Render(new
{
title,
header=string.Join("\r",atHead?.Invoke()??new[]{""})
});

varbody=_templates.body.Render(new
{
PageName=KebabToNormalCase(title),
Content=string.Join("\r",atBody?.Invoke()??new[]{""}),
AtSidePanel=string.Join("\r",atSidePanel?.Invoke()??new[]{""}),
AtFoot=string.Join("\r",atFoot?.Invoke()??new[]{""})
});

returnnewHtmlString(_templates.layout.Render(new{head,body}));
}
}

classWiki
{
DateTimeTimestamp()=>DateTime.UtcNow;

conststringPageCollectionName="Pages";
conststringAllPagesKey="AllPages";
constdoubleCacheAllPagesForMinutes=30;

readonlyIWebHostEnvironment_env;
readonlyIMemoryCache_cache;
readonlyILogger_logger;

publicWiki(IWebHostEnvironmentenv,IMemoryCachecache,ILogger<Wiki>logger)
{
_env=env;
_cache=cache;
_logger=logger;
}

// Get the location of the LiteDB file.
stringGetDbPath()=>Path.Combine(_env.ContentRootPath,"wiki.db");

// List all the available wiki pages. It is cached for 30 minutes.
publicList<Page>ListAllPages()
{
varpages=_cache.Get(AllPagesKey)asList<Page>;

if(pagesisobject)
returnpages;

usingvardb=newLiteDatabase(GetDbPath());
varcoll=db.GetCollection<Page>(PageCollectionName);
varitems=coll.Query().ToList();

_cache.Set(AllPagesKey,items,newMemoryCacheEntryOptions().SetAbsoluteExpiration(TimeSpan.FromMinutes(CacheAllPagesForMinutes)));
returnitems;
}

// Get a wiki page based on its path
publicPage?GetPage(stringpath)
{
usingvardb=newLiteDatabase(GetDbPath());
varcoll=db.GetCollection<Page>(PageCollectionName);
coll.EnsureIndex(x =>x.Name);

returncoll.Query()
.Where(x =>x.Name.Equals(path,StringComparison.OrdinalIgnoreCase))
.FirstOrDefault();
}

// Save or update a wiki page. Cache(AllPagesKey) will be destroyed.
public(boolisOk,Page?page,Exception?ex)SavePage(PageInputinput)
{
try
{
usingvardb=newLiteDatabase(GetDbPath());
varcoll=db.GetCollection<Page>(PageCollectionName);
coll.EnsureIndex(x =>x.Name);

Page?existingPage=input.Id.HasValue?coll.FindOne(x =>x.Id==input.Id):null;

varsanitizer=newHtmlSanitizer();
varproperName=input.Name.ToString().Trim().Replace(' ','-').ToLower();

Attachment?attachment=null;
if(!string.IsNullOrWhiteSpace(input.Attachment?.FileName))
{
attachment=newAttachment
(
FileId:Guid.NewGuid().ToString(),
FileName:input.Attachment.FileName,
MimeType:input.Attachment.ContentType,
LastModifiedUtc:Timestamp()
);

usingvarstream=input.Attachment.OpenReadStream();
varres=db.FileStorage.Upload(attachment.FileId,input.Attachment.FileName,stream);
}

if(existingPageis not object)
{
varnewPage=newPage
{
Name=sanitizer.Sanitize(properName),
Content=input.Content,//Do not sanitize on input because it will impact some markdown tag such as >. We do it on the output instead.
LastModifiedUtc=Timestamp()
};

if(attachmentisobject)
newPage.Attachments.Add(attachment);

coll.Insert(newPage);

_cache.Remove(AllPagesKey);
return(true,newPage,null);
}
else
{
varupdatedPage=existingPagewith
{
Name=sanitizer.Sanitize(properName),
Content=input.Content,//Do not sanitize on input because it will impact some markdown tag such as >. We do it on the output instead.
LastModifiedUtc=Timestamp()
};

if(attachmentisobject)
updatedPage.Attachments.Add(attachment);

coll.Update(updatedPage);

_cache.Remove(AllPagesKey);
return(true,updatedPage,null);
}
}
catch(Exceptionex)
{
_logger.LogError(ex,$"There is an exception in trying to save page name '{input.Name}'");
return(false,null,ex);
}
}

public(boolisOk,Page?p,Exception?ex)DeleteAttachment(intpageId,stringid)
{
try
{
usingvardb=newLiteDatabase(GetDbPath());
varcoll=db.GetCollection<Page>(PageCollectionName);
varpage=coll.FindById(pageId);
if(pageis not object)
{
_logger.LogWarning($"Delete attachment operation fails because page id {id} cannot be found in the database");
return(false,null,null);
}

if(!db.FileStorage.Delete(id))
{
_logger.LogWarning($"We cannot delete this file attachment id {id} and it's a mystery why");
return(false,page,null);
}

page.Attachments.RemoveAll(x =>x.FileId.Equals(id,StringComparison.OrdinalIgnoreCase));

varupdateResult=coll.Update(page);

if(!updateResult)
{
_logger.LogWarning($"Delete attachment works but updating the page (id {pageId}) attachment list fails");
return(false,page,null);
}

return(true,page,null);
}
catch(Exceptionex)
{
return(false,null,ex);
}
}

public(boolisOk,Exception?ex)DeletePage(intid,stringhomePageName)
{
try
{
usingvardb=newLiteDatabase(GetDbPath());
varcoll=db.GetCollection<Page>(PageCollectionName);

varpage=coll.FindById(id);

if(pageis not object)
{
_logger.LogWarning($"Delete operation fails because page id {id} cannot be found in the database");
return(false,null);
}

if(page.Name.Equals(homePageName,StringComparison.OrdinalIgnoreCase))
{
_logger.LogWarning($"Page id {id} is a home page and elete operation on home page is not allowed");
return(false,null);
}

//Delete all the attachments
foreach(varainpage.Attachments)
{
db.FileStorage.Delete(a.FileId);
}

if(coll.Delete(id))
{
_cache.Remove(AllPagesKey);
return(true,null);
}

_logger.LogWarning($"Somehow we cannot delete page id {id} and it's a mistery why.");
return(false,null);
}
catch(Exceptionex)
{
return(false,ex);
}
}

// Return null if file cannot be found.
public(LiteFileInfo<string>meta,byte[]file)?GetFile(stringfileId)
{
usingvardb=newLiteDatabase(GetDbPath());

varmeta=db.FileStorage.FindById(fileId);
if(metais not object)
returnnull;

usingvarstream=newMemoryStream();
db.FileStorage.Download(fileId,stream);
return(meta,stream.ToArray());
}
}

recordPage
{
publicintId{get;set;}

publicstringName{get;set;}=string.Empty;

publicstringContent{get;set;}=string.Empty;

publicDateTimeLastModifiedUtc{get;set;}

publicList<Attachment>Attachments{get;set;}=new();
}

recordAttachment
(
stringFileId,

stringFileName,

stringMimeType,

DateTimeLastModifiedUtc
);

recordPageInput(int?Id,stringName,stringContent,IFormFile?Attachment)
{
publicstaticPageInputFrom(IFormCollectionform)
{
var(id,name,content)=(form["Id"],form["Name"],form["Content"]);

int?pageId=null;

if(!StringValues.IsNullOrEmpty(id))
pageId=Convert.ToInt32(id);

IFormFile?file=form.Files["Attachment"];

returnnewPageInput(pageId,name!,content!,file);
}
}

classPageInputValidator:AbstractValidator<PageInput>
{
publicPageInputValidator(stringpageName,stringhomePageName)
{
RuleFor(x =>x.Name).NotEmpty().WithMessage("Name is required");
if(pageName.Equals(homePageName,StringComparison.OrdinalIgnoreCase))
RuleFor(x =>x.Name).Must(name =>name.Equals(homePageName)).WithMessage($"You cannot modify home page name. Please keep it {homePageName}");

RuleFor(x =>x.Content).NotEmpty().WithMessage("Content is required");
}
}