public static void Configure()
{
var options = new MarkdownOptions { AutoHyperlink = true };
var converter = new Markdown(options);
Mapper.CreateMap<Entry, EntryViewModel>()
// convert content from markdown to html
.ForMember(entry => entry.Content,
expression => expression.ResolveUsing(source => converter.Transform(source.Content)))
// convert summary from markdown to html
.ForMember(entry => entry.Summary,
expression => expression.ResolveUsing(source => converter.Transform(source.Summary)));
// convert the closed type of the derived generic list
Mapper.CreateMap<PagedList<Entry>, PagedList<EntryViewModel>>()
.AfterMap((entity, model) => Mapper.Map<List<Entry>, List<EntryViewModel>>(entity, model));
Mapper.CreateMap<EntryInput, Entry>()
.ForMember(entry => entry.Slug, expression => expression.MapFrom(
entry => SlugConverter.Convert(entry.Header)))
.ForMember(entry => entry.Tags, expression => expression.MapFrom(
entry => TagsResolver.ResolveTags(entry.Tags)));
Mapper.CreateMap<Entry, EntryInput>()
.ForMember(entry => entry.Tags, opt => opt.MapFrom(
entry => TagsResolver.ResolveTags(entry.Tags)));
Mapper.CreateMap<Entry, EntryInput>();
}
static void TestMarkdownSharp()
{
var result = new Result {
Name = "MarkdownSharp"
};
var stopwatch = Stopwatch.StartNew();
var warmup = new MarkdownSharp.Markdown();
warmup.Transform(testTexts.First());
stopwatch.Stop();
result.WarmUp = stopwatch.ElapsedMilliseconds;
stopwatch = Stopwatch.StartNew();
var markdownify = new MarkdownSharp.Markdown();
stopwatch.Stop();
result.Construction = stopwatch.ElapsedMilliseconds;
stopwatch = Stopwatch.StartNew();
markdownify.Transform(testTexts.First());
stopwatch.Stop();
result.FirstRun = stopwatch.ElapsedMilliseconds;
stopwatch = Stopwatch.StartNew();
foreach (var text in testTexts)
{
markdownify.Transform(text);
}
stopwatch.Stop();
result.BulkRun = stopwatch.ElapsedMilliseconds;
result.Average = GetAverage(stopwatch.ElapsedMilliseconds);
results.Add(result);
}
public void TestEncodeProblemUrlCharacters()
{
var markdown = new Markdown();
Assert.IsFalse(markdown.EncodeProblemUrlCharacters);
Assert.AreEqual("<p><a href=\"/'*_[]()/\">Foo</a></p>\n", markdown.Transform("[Foo](/'*_[]()/)"));
markdown.EncodeProblemUrlCharacters = true;
Assert.AreEqual("<p><a href=\"/%27%2a%5f%5b%5d%28%29/\">Foo</a></p>\n", markdown.Transform("[Foo](/'*_[]()/)"));
}
public void TestAutoNewLines()
{
var markdown = new Markdown();
Assert.IsFalse(markdown.AutoNewLines);
Assert.AreEqual("<p>Line1\nLine2</p>\n", markdown.Transform("Line1\nLine2"));
markdown.AutoNewLines = true;
Assert.AreEqual("<p>Line1<br />\nLine2</p>\n", markdown.Transform("Line1\nLine2"));
}
public void TestAutoHyperlink()
{
var markdown = new Markdown();
Assert.IsFalse(markdown.AutoHyperlink);
Assert.AreEqual("<p>foo http://example.com bar</p>\n", markdown.Transform("foo http://example.com bar"));
markdown.AutoHyperlink = true;
Assert.AreEqual("<p>foo <a href=\"http://example.com\">http://example.com</a> bar</p>\n", markdown.Transform("foo http://example.com bar"));
}
public void TestEmptyElementSuffix()
{
var markdown = new Markdown();
Assert.AreEqual(" />", markdown.EmptyElementSuffix);
Assert.AreEqual("<hr />\n", markdown.Transform("* * *"));
markdown.EmptyElementSuffix = ">";
Assert.AreEqual("<hr>\n", markdown.Transform("* * *"));
}
public void TestLinkEmails()
{
var markdown = new Markdown();
Assert.IsTrue(markdown.LinkEmails);
Assert.AreEqual("<p><a href=\"&#", markdown.Transform("<*****@*****.**>").Substring(0,14));
markdown.LinkEmails = false;
Assert.AreEqual("<p><*****@*****.**></p>\n", markdown.Transform("<*****@*****.**>"));
}
public static string MarkdownEncode(this string s)
{
var md = new MarkdownSharp.Markdown();
md.CodeClass = " class=\"prettyprint\"";
return(md.Transform(s));
}
public Response RenderView(ViewLocationResult viewLocationResult, dynamic model, IRenderContext renderContext)
{
var response = new HtmlResponse();
var html = renderContext.ViewCache.GetOrAdd(viewLocationResult, result =>
{
string markDown =
viewLocationResult.Contents()
.ReadToEnd();
var parser = new Markdown();
return parser.Transform(markDown);
});
var serverHtml = ParagraphSubstitution.Replace(html, "$1");
var renderHtml = this.engineWrapper.Render(serverHtml, model, new MarkdownViewEngineHost(new NancyViewEngineHost(renderContext), renderContext));
response.Contents = stream =>
{
var writer = new StreamWriter(stream);
writer.Write(renderHtml);
writer.Flush();
};
return response;
}
public string GetHtml(string postid)
{
var md = new MarkdownSharp.Markdown();
var g = _dbhelper.GetPostFromId(postid);
return(md.Transform(g.PostContent));
}
private string GetContent()
{
var md = new Markdown(new MarkdownOptions { AutoHyperlink = true });
// Code is converted to <pre><code>, I just want the code tag:
var html = md.Transform(_content).Replace("<pre><code>", "<code>").Replace("</code></pre>", "</code>");
return html;
}
public string Execute(string source, IDictionary<string, object> arguments)
{
var markdown = new Markdown();
string output = markdown.Transform(source);
return output;
}
public static void SendEmail(Suggestion suggestion)
{
var markdown = new Markdown();
var appName = WebConfigurationManager.AppSettings["AppName"];
var appUrl = WebConfigurationManager.AppSettings["AppUrl"];
var smtpServer = WebConfigurationManager.AppSettings["SmtpServer"];
var fromAddress = WebConfigurationManager.AppSettings["EmailFrom"];
var toAddress = WebConfigurationManager.AppSettings["EmailTo"];
var subject = string.Format("{0}: {1}", appName, suggestion.Title);
var body = string.Format(@"<p>""{0}"" has been submitted to {1}.</p>
{2}
<p>You can view the suggestion <a href=""{3}Suggestions/View/{4}"">here</a>.</p>", suggestion.Title, appName, markdown.Transform(suggestion.Body), appUrl, suggestion.Id);
var message = new MailMessage(fromAddress, toAddress)
{
Subject = subject,
Body = body,
IsBodyHtml = true
};
var client = new SmtpClient(smtpServer);
client.Send(message);
}
public void ProcessRequest(HttpContext context) {
context.Response.ContentType = "text/html";
var markdown = context.Request.QueryString["markdown"];
var processor = new Markdown();
context.Response.Write(processor.Transform(markdown));
}
private void MarkDownTextBox_Load(object sender, EventArgs e)
{
if(this.DesignModeAtAll())
return;
var markdownTransformer = new Markdown();
_htmlLabel.HTML = markdownTransformer.Transform(_markdown);
}
public static void Main(string[] args)
{
Markdown md = new Markdown ();
var markup = File.ReadAllText (args[0]);
var html = md.Transform (markup);
Console.WriteLine (html);
}
public string Process(string input)
{
var options = new MarkdownOptions();
var markdown = new Markdown();
var output = markdown.Transform(input);
return output;
}
/// <summary>
/// Renders stand alone / master page
/// </summary>
/// <param name="templateContent">Template content</param>
/// <returns>HTML converted to markdown</returns>
public static string RenderMasterPage(string templateContent)
{
var second =
templateContent.Substring(
templateContent.IndexOf("<!DOCTYPE html>", StringComparison.OrdinalIgnoreCase),
templateContent.IndexOf("<body", StringComparison.OrdinalIgnoreCase));
var third = templateContent.Substring(second.Length);
var forth = templateContent.Substring(second.Length, third.IndexOf(">", StringComparison.Ordinal) + 1);
var header = second + forth;
var toConvert = templateContent.Substring(header.Length,
(templateContent.IndexOf("</body>", StringComparison.Ordinal) -
(templateContent.IndexOf(forth, StringComparison.Ordinal) + forth.Length)));
var footer =
templateContent.Substring(templateContent.IndexOf("</body>", StringComparison.OrdinalIgnoreCase));
var parser = new Markdown();
var html = parser.Transform(toConvert.Trim());
var serverHtml = ParagraphSubstitution.Replace(html, "$1");
//TODO: The "Replace" is simply for unit testing HTML/MD strings. Probably needs improving
return string.Concat(header, serverHtml, footer).Replace("\r\n", "").Replace("\n", "").Replace("\r", "");
}
public ActionResult Preview(string data)
{
var md = new Markdown();
var html = md.Transform(data);
ViewBag.Preview = html;
return PartialView();
}
private static IEnumerable<TestCaseData> GetTests()
{
Markdown m = new Markdown();
Assembly assembly = Assembly.GetAssembly(typeof(BaseTest));
string namespacePrefix = String.Concat(assembly.GetName().Name, '.', folder);
string[] resourceNames = assembly.GetManifestResourceNames();
Func<string, string> getResourceFileContent = filename =>
{
using (Stream stream = assembly.GetManifestResourceStream(filename))
{
if (stream == null)
return null;
using (StreamReader streamReader = new StreamReader(stream))
return streamReader.ReadToEnd();
}
};
return from name in resourceNames
// Skip resource names that aren't within the namespace (folder) we want
// and doesn't have the extension '.html'.
where name.StartsWith(namespacePrefix) && name.EndsWith(".html")
let actualName = Path.ChangeExtension(name, "text")
let actualContent = getResourceFileContent(actualName)
let actual = Program.RemoveWhitespace(m.Transform(actualContent))
let expectedContent = getResourceFileContent(name)
let expected = Program.RemoveWhitespace(expectedContent)
select new TestCaseData(actualName, name, actual, expected);
}
private void ShowReadme()
{
var source = File.ReadAllText(_readmePath);
var mark = new Markdown(_options);
var headerHtml = @"<!DOCTYPE html>
<head>
<meta charset='utf-8'>
<link rel='stylesheet' type='text/css' href='
"
+
_stylePath
+
@"' />
</head>
<body>
";
const string footerHtml = @"</body>";
var htmlString = headerHtml + mark.Transform(source) + footerHtml;
WbReadme.NavigateToString(htmlString);
}
private static string MarkdownReplace(string text) {
if (string.IsNullOrEmpty(text))
return string.Empty;
var markdown = new MarkdownSharp.Markdown(new MarkdownOptions { AutoNewLines = false });
return markdown.Transform(text);
}
private void CreateAndPublish(Post p)
{
var stream = getStream();
if (stream != null)
{
var cs = new ContentService();
int postId;
IContent post;
if (TryGetPostId(p, out postId))
post = cs.GetById(postId);
else
{
var parent = createFolderScructure(p.Date, stream);
post = cs.CreateContent(p.Name, parent, PostTypeAlias);
}
MarkdownSharp.Markdown md = new Markdown();
post.SetValue("bodyText", md.Transform(p.Content));
post.SetValue("postDate", p.Date);
if (p.Draft)
cs.Save(post);
else
cs.SaveAndPublish(post);
}
}
private string transform(string text)
{
if (string.IsNullOrEmpty(text))
return string.Empty;
var parser = new Markdown();
parser.ExtendWith(new StatefulCheckboxPattern());
var t = parser.Transform(text);
//prevent html from being replaced by wikiwords
var htmlTags = new Queue<string>();
t = _htmlTagsRegex.Replace(t, m =>
{
htmlTags.Enqueue(m.Groups[0].Value);
return _emaPlaceholder;
});
//don't extend markdown with this pattern because it will destroy links
t = new WikiWordsPattern().Transform(t);
return _htmlTagsRegex.Replace(t, m =>
{
if (m.Groups[0].Value == _emaPlaceholder)
{
return htmlTags.Dequeue();
}
else
{
//new wikiword link
return m.Groups[0].Value;
}
});
}
private SyndicationItem FormatLogEntry(LogEntry entry, string repo)
{
var markdownParser = new Markdown(true);
var item = new SyndicationItem();
item.Id = entry.CommitHash;
item.Title = new TextSyndicationContent(entry.Subject);
item.Content = SyndicationContent.CreateHtmlContent(markdownParser.Transform(entry.Subject + "\n\n" + entry.Body));
item.LastUpdatedTime = entry.AuthorDate;
item.PublishDate = entry.CommitterDate;
item.Links.Add(SyndicationLink.CreateAlternateLink(new Uri(Url.Action("ViewCommit", "Browse", new { repo, @object = entry.CommitHash }), UriKind.Relative)));
item.Categories.Add(new SyndicationCategory("commit"));
if (entry.Parents.Count > 1)
{
item.Categories.Add(new SyndicationCategory("merge"));
}
item.Authors.Add(new SyndicationPerson(entry.AuthorEmail, entry.Author, null));
if (entry.Author != entry.Committer || entry.AuthorEmail != entry.CommitterEmail)
{
item.Contributors.Add(new SyndicationPerson(entry.CommitterEmail, entry.Committer, null));
}
return item;
}
public void Process(RenderFieldArgs args)
{
Assert.ArgumentNotNull(args, "args");
if (!string.IsNullOrEmpty(args.FieldValue))
{
args.Result.FirstPart = args.FieldValue;
}
else
{
args.Result.FirstPart = args.Item[args.FieldName];
}
if (args.FieldTypeKey == "rich text")
{
WordFieldValue wordFieldValue = WordFieldValue.Parse(args.Result.FirstPart);
if (wordFieldValue.BlobId != ID.Null)
{
args.Result.FirstPart = wordFieldValue.GetHtmlWithStyles();
}
}
if (args.FieldTypeKey == "markdownfield")
{
var markdown = new Markdown();
args.Result.FirstPart = markdown.Transform(args.FieldValue);
}
}
static void Main(string[] args)
{
if (args.Length == 0)
{
DisplayHelp();
return;
}
else if (args.Length > 2)
{
Console.WriteLine("Invalid number of arguments. Usage:\n");
DisplayHelp();
return;
}
try
{
Markdown m = new Markdown();
string sourceDirectory = args[0];
string destinationDirectory = (args.Length == 2) ? args[1] : sourceDirectory;
foreach (string file in Directory.GetFiles(sourceDirectory))
{
string fileName = Path.GetFileNameWithoutExtension(file);
string transformedText = m.Transform(File.ReadAllText(file));
string newFile = Path.Combine(sourceDirectory, fileName + ".html");
File.WriteAllText(newFile, transformedText);
}
Console.WriteLine("Conversion complete.");
}
catch (Exception ex)
{
Console.WriteLine("Errors occured during conversion: {0}", ex.Message);
}
}
public static Post Parse(string fileData)
{
var lines = fileData.Split(new[] { Environment.NewLine }, StringSplitOptions.None);
var metadata = new Dictionary<string, string>();
if (lines.Any() && lines[0] != "---")
{
return null;
}
var ii = 1;
for (; ii < lines.Length; ii++ )
{
if (lines[ii] == "---")
{
break;
}
var parts = lines[ii].Split(':');
metadata.Add(parts[0].Trim(), parts[1].Trim());
}
var content = string.Join(Environment.NewLine, lines.Skip(ii + 1).ToArray());
var md = new Markdown();
return new Post
{
Title = metadata["title"],
PublishDate = DateTime.Parse(metadata["date"]),
Content = md.Transform(content)
};
}
private async Task RunAsync()
{
try
{
using (var client = new HttpClient())
{
client.BaseAddress = new Uri("https://api.github.com/");
client.DefaultRequestHeaders.Accept.Clear();
client.DefaultRequestHeaders.Accept.Add(new MediaTypeWithQualityHeaderValue("application/json"));
client.DefaultRequestHeaders.Add("User-Agent", userName);
HttpResponseMessage response =
await
client.GetAsync(string.Format("repos/{0}/{1}/releases", userName, repositoryName))
.ConfigureAwait(continueOnCapturedContext: false);
response.EnsureSuccessStatusCode();
if (response.IsSuccessStatusCode)
{
var data = response.Content.ReadAsStringAsync();
var jSserializer = new JavaScriptSerializer();
var releases = jSserializer.Deserialize<List<RootObject>>(data.Result);
var lastRelease = releases.OrderByDescending(r => r.created_at).FirstOrDefault(r => r.prerelease == false);
if (lastRelease != null)
{
var version = lastRelease.tag_name.Replace("v.", "");
var versionParts = version.Split('.');
int majorVersion = int.Parse(versionParts[0]);
int minorVersion = int.Parse(versionParts[1]);
int buildVersion = int.Parse(versionParts[2]);
int revisionVersion = int.Parse(versionParts[3]);
if (currentMajorVersion < majorVersion
|| currentMajorVersion == majorVersion && currentMinorVersion < minorVersion
||
currentMajorVersion == majorVersion && currentMinorVersion == minorVersion &&
currentBuildVersion < buildVersion
||
currentMajorVersion == majorVersion && currentMinorVersion == minorVersion &&
currentBuildVersion == buildVersion && currentRevisionVersion < revisionVersion)
{
var mdth = new Markdown();
var html = mdth.Transform(lastRelease.body).Replace("h1", "div");
Cpi = new GithubInformation
{
Description = html,
Version = version
};
}
}
}
}
}
catch
{
// Do nothing as we don't want to throw exception if something goes wrong with checking update
}
}
public Action<Section> Convert(string contents)
{
var converter = new MarkdownSharp.Markdown(options);
var html = converter.Transform(contents);
var htmlConverter = new HtmlConverter();
return htmlConverter.Convert(html);
}
public string GetDescription(IPresentableItem item)
{
var description = this.itemPresenter.GetDescription(item);
var markdown = new Markdown();
var transformedDescription = markdown.Transform(description);
return transformedDescription;
}
public void TestStrictBoldItalic()
{
var markdown = new Markdown();
Assert.IsFalse(markdown.StrictBoldItalic);
Assert.AreEqual("<p>before<strong>bold</strong>after before<em>italic</em>after</p>\n", markdown.Transform("before**bold**after before_italic_after"));
markdown.StrictBoldItalic = true;
Assert.AreEqual("<p>before*bold*after before_italic_after</p>\n", markdown.Transform("before*bold*after before_italic_after"));
}
public static void Initialize()
{
var markdown = new Markdown();
Mapper.CreateMap<Suggestion, SuggestionModel>()
.ForMember(dest => dest.Body, opt => opt.MapFrom(src => markdown.Transform(src.Body)))
.ForMember(dest => dest.Status, opt => opt.MapFrom(src => (SuggestionStatus)src.Status))
.ForMember(dest => dest.LastActivity,
opt => opt.MapFrom(src => src.Comments.Count == 0 ? src.Date : src.Comments.Max(c => c.Date)));
Mapper.CreateMap<SuggestionModel, Suggestion>()
.ForMember(dest => dest.Status, opt => opt.MapFrom(src => (int)src.Status));
Mapper.CreateMap<Comment, CommentModel>()
.ForMember(dest => dest.Body, opt => opt.MapFrom(src => markdown.Transform(src.Body)))
.ForMember(dest => dest.Status, opt => opt.MapFrom(src => (CommentStatus)src.Status));
Mapper.CreateMap<CommentModel, Comment>()
.ForMember(dest => dest.Status, opt => opt.MapFrom(src => (int)src.Status));
}
protected virtual string ApplyTransformation(string markdownContent)
{
foreach (var preTransformation in Tranformers.GetTransformers())
{
markdownContent = preTransformation.Invoke(markdownContent);
}
return(_markdown.Transform(markdownContent).Replace("\n", "\r\n"));
}
public Action <Section> Convert(string contents)
{
var converter = new MarkdownSharp.Markdown(options);
var html = converter.Transform(contents);
var htmlConverter = new HtmlConverter();
return(htmlConverter.Convert(html));
}
protected void Page_Load(object sender, EventArgs e)
{
if (!IsPostBack)
{
SystemInit();
var markdown = new MarkdownSharp.Markdown();
Bmdxx bmd = Bmdxx.FindOne(Condition.Empty);
if (bmd != null)
{
var html = markdown.Transform(bmd.Wiki1);
this.ed_Wiki1.Text = html;
html = markdown.Transform(bmd.Wiki2);
this.ed_Wiki2.Text = html;
}
}
if (!Request.IsAuthenticated)
{
Response.Redirect("~/Account/Login.aspx");
}
//if (Request.IsAuthenticated && !User.IsInRole("Administrators"))
//{
// if (User.IsInRole("Students"))
// {
// Response.Redirect("frmStudent.aspx");
// }
// else if (User.IsInRole("Teachers"))
// {
// Response.Redirect("InputIndex.aspx");
// }
//}
if (Request.IsAuthenticated)
{
this.Login1.Visible = false;
}
}
private static string MarkdownReplace(string text)
{
if (string.IsNullOrEmpty(text))
{
return(string.Empty);
}
var markdown = new MarkdownSharp.Markdown(new MarkdownOptions {
AutoNewLines = true
});
return(markdown.Transform(text));
}
public static MvcHtmlString Resolve(string inputBody)
{
var md = new MarkdownSharp.Markdown(new MarkdownOptions
{
AutoHyperlink = true,
AutoNewLines = true,
EncodeProblemUrlCharacters = true,
LinkEmails = false,
StrictBoldItalic = true
});
var result = md.Transform(inputBody);
return(MvcHtmlString.Create(result));
}
public string Execute(string[] parameters)
{
if (parameters.Any() == false)
{
throw new ArgumentOutOfRangeException(nameof(parameters));
}
// Parameter zero holds all the content for default commands
var input = parameters[0];
var markdown = new MarkdownSharp.Markdown();
var output = markdown.Transform(input);
return(output);
}
public string Parse(string content)
{
if (string.IsNullOrWhiteSpace(content))
{
return(string.Empty);
}
var markdownOptions = new MarkdownOptions
{
AutoHyperlink = true
};
var markdown = new MarkdownSharp.Markdown(markdownOptions);
return(markdown.Transform(content));
}
/// <summary>
/// Transforms the Markdown value to HTML.
/// </summary>
/// <param name="data">The data (Markdown) to transform into HTML.</param>
/// <returns>Returns an HTML representation of the data.</returns>
public override XmlNode ToXMl(XmlDocument data)
{
// check that the value isn't null
if (this.Value != null && !string.IsNullOrEmpty(this.Value.ToString()))
{
// transform the markdown into HTML.
var markdown = new MarkdownSharp.Markdown();
string output = markdown.Transform(this.Value.ToString());
// return the transformed HTML (as CDATA)
return(data.CreateCDataSection(output));
}
else
{
// otherwise render the value as default (in CDATA)
return(base.ToXMl(data));
}
}
protected void Page_Load(object sender, EventArgs e)
{
// RegisterHyperLink.NavigateUrl = "Register.aspx?ReturnUrl=" + HttpUtility.UrlEncode(Request.QueryString["ReturnUrl"]);
if (Request.IsAuthenticated)
{
if (User.IsInRole("Students"))
{
// Response.Redirect("frmStudent.aspx");
Response.Redirect("~/frmZhiyuanEdit.aspx");
}
}
if (!IsPostBack)
{
var markdown = new MarkdownSharp.Markdown();
Bmdxx bmd = Bmdxx.FindOne(Condition.Empty);
if (bmd != null)
{
var html = markdown.Transform(bmd.Wiki1);
this.ed_Wiki1.Text = html;
}
}
}
/// <summary>
/// Transforms the Markdown value to HTML.
/// </summary>
/// <param name="data">The data (Markdown) to transform into HTML.</param>
/// <returns>Returns an XML representation of the data.</returns>
public override XmlNode ToXMl(XmlDocument data)
{
// check that the value isn't null
if (this.Value != null && !string.IsNullOrEmpty(this.Value.ToString()))
{
// transform the markdown into HTML.
var markdown = new MarkdownSharp.Markdown();
string output = markdown.Transform(this.Value.ToString());
// load the HTML into an XML document.
var xd = new XmlDocument();
xd.LoadXml(string.Concat("<html>", output, "</html>"));
// return the XML node.
return(data.ImportNode(xd.DocumentElement, true));
}
else
{
// otherwise render the value as default (in CDATA)
return(base.ToXMl(data));
}
}
public static InstallSet GetInstall()
{
InstallSet s = new InstallSet();
var md = new MarkdownSharp.Markdown();
var welcomemsg = "You have successfully installed _Writa_ - a publishing and blogging platform, that focuses on simplicity. Built from the ground up to be *easy to customise* and with all the features you would expect.\n\n### Editing Posts \n\n Editing content is done using Markdown, a simple syntax for adding rich content to your pages. You can add and edit pages using your admin control panel. Checkout the help pages at <a href=\"http://writa.org\">http://writa.org</a> for more information.";
var welcomemsghtml = md.Transform(welcomemsg);
//s.u = new WritaUser() { };
s.homepage = new WritaPost()
{
PostStatus = WritaPostStatus.PUBLISHED, PostType = WritaPostType.HOMEPAGE, PostParent = "", PostSummary = "This is your blog homepage", PostId = System.Guid.NewGuid().ToString(), Homepage = true, PostContent = "", PostAuthor = "", PostCreated = DateTime.Now, PostLastEdited = DateTime.Now, PostStartDate = DateTime.Now, PostThumbnail = "", PostSlug = "homepage", PostTitle = "Welcome to Writa - Your Blog Homepage"
};
s.firstpost = new WritaPost()
{
PostStatus = WritaPostStatus.PUBLISHED, PostType = WritaPostType.BLOGPOST, PostParent = "", PostSummary = "Congratulations, you have just installed <b>Writa</b> - a beautifully simple and easy to use blogging platform built with customisation in mind from the ground up. ", PostStartDate = DateTime.Now, PostThumbnail = "/content/logo.jpg", PostId = System.Guid.NewGuid().ToString(), Homepage = true, PostContent = welcomemsg, PostAuthor = "", PostCreated = DateTime.Now, PostLastEdited = DateTime.Now, PostSlug = "welcome to writa", PostTitle = "Welcome to Writa"
};
s.settings = new WritaSettings()
{
SettingsId = System.Guid.NewGuid().ToString(), BlogTitle = "Welcome To Writa", BlogTheme = "Default", BlogSummary = "Welcome to Writa"
};
return(s);
}
static ConvertFileResponse ConvertFile(MarkdownSharp.Markdown markdownToHtml, string inputFileName, string language, IEnumerable <string> languagesLinksToGenerate, OutputFormat format = OutputFormat.HTML)
{
var result = ConvertFileResponse.NoChange;
var targetFileName = GetTargetFileName(inputFileName, language);
//Set up parameters in Markdown to aid in processing and generating html
Markdown.MetadataErrorIfMissing = MetadataErrorIfMissing;
Markdown.MetadataInfoIfMissing = MetadataInfoIfMissing;
markdownToHtml.DoNotPublishAvailabilityFlag = Settings.Default.DoNotPublishAvailabilityFlag;
markdownToHtml.PublishFlags = PublishFlags.ToList();
markdownToHtml.AllSupportedAvailability = AllSupportedAvailability;
var fileOutputDirectory = FileHelper.GetRelativePath(
SourceDirectory, Path.GetDirectoryName(inputFileName));
var currentFolderDetails = new FolderDetails(
GetRelativeHTMLPath(targetFileName), OutputDirectory, SourceDirectory, fileOutputDirectory,
Settings.Default.APIFolderLocation,
(new DirectoryInfo(inputFileName).Parent).FullName.Replace(
SourceDirectory + Path.DirectorySeparatorChar.ToString(), "")
.Replace(SourceDirectory, "")
.Replace(Path.DirectorySeparatorChar.ToString(), " - "),
language);
markdownToHtml.DefaultTemplate = DefaultTemplate;
markdownToHtml.ThisIsPreview = ThisIsPreview;
if (language != "INT")
{
currentFolderDetails.DocumentTitle += " - " + language;
}
if (ThisIsPreview)
{
currentFolderDetails.DocumentTitle += " - PREVIEW!";
}
markdownToHtml.SupportedLanguages = SupportedLanguages;
markdownToHtml.SupportedLanguageLabels = SupportedLanguageLabels;
for (int i = 0; i < markdownToHtml.SupportedLanguages.Length; i++)
{
if (!markdownToHtml.SupportedLanguageMap.ContainsKey(SupportedLanguages[i]))
{
markdownToHtml.SupportedLanguageMap.Add(markdownToHtml.SupportedLanguages[i], markdownToHtml.SupportedLanguageLabels[i]);
}
}
//Pass the default conversion settings to Markdown for use in the image details creation.
markdownToHtml.DefaultImageDoCompress = DoCompressImages;
markdownToHtml.DefaultImageFormatExtension = CompressImageType;
markdownToHtml.DefaultImageFillColor = DefaultImageFillColor;
markdownToHtml.DefaultImageFormat = CompressImageFormat;
markdownToHtml.DefaultImageQuality = JpegCompressionRate;
var errorList = new List <ErrorDetail>();
var imageDetails = new List <ImageConversion>();
var attachNames = new List <AttachmentConversionDetail>();
var output = markdownToHtml.Transform(FileContents(inputFileName), errorList, imageDetails, attachNames, currentFolderDetails, languagesLinksToGenerate, format != OutputFormat.HTML);
var noFailedErrorReport = true;
var stopProcessing = false;
//If output empty then treat as failed, we are not converting most likely due to the publish flags and availability settings
if (String.IsNullOrWhiteSpace(output))
{
noFailedErrorReport = false;
stopProcessing = true;
result = ConvertFileResponse.NoChange;
log.Info(MarkdownSharp.Language.Message("NotConverted", inputFileName));
}
else
{
//Need to check for error types prior to processing to output log messages in the correct order.
foreach (var errorInfo in errorList)
{
if (errorInfo.ClassOfMessage == MessageClass.Error || errorInfo.ClassOfMessage == MessageClass.Warning)
{
log.Info(MarkdownSharp.Language.Message("FileFailed", inputFileName));
noFailedErrorReport = false;
break;
}
}
}
if (noFailedErrorReport)
{
log.Info(MarkdownSharp.Language.Message("Converted", inputFileName));
}
//On warnings or errors stop processing the file to the publish folder but allow to continue if in preview.
if (errorList.Count > 0)
{
Console.Write("\n");
foreach (MarkdownSharp.ErrorDetail ErrorInfo in errorList)
{
switch (ErrorInfo.ClassOfMessage)
{
case MarkdownSharp.MessageClass.Error:
log.Error(ErrorInfo.Path ?? inputFileName, ErrorInfo.Line, ErrorInfo.Column, ErrorInfo.Message);
if (!ThisIsPreview)
{
stopProcessing = true;
result = ConvertFileResponse.Failed;
}
break;
case MarkdownSharp.MessageClass.Warning:
log.Warn(ErrorInfo.Path ?? inputFileName, ErrorInfo.Line, ErrorInfo.Column, ErrorInfo.Message);
if (!ThisIsPreview)
{
stopProcessing = true;
result = ConvertFileResponse.Failed;
}
break;
default:
log.Info(ErrorInfo.Path ?? inputFileName, ErrorInfo.Line, ErrorInfo.Column, ErrorInfo.Message);
break;
}
}
}
if (!stopProcessing)
{
if (ThisIsPreview || !ThisIsLogOnly)
{
CommonUnrealFunctions.CopyDocumentsImagesAndAttachments(inputFileName, log, OutputDirectory, language, fileOutputDirectory, imageDetails, attachNames);
}
var expected = FileContents(targetFileName);
if (output == expected)
{
result = ConvertFileResponse.NoChange;
}
else
{
if (!stopProcessing)
{
if (!AlreadyCreatedCommonDirectories)
{
AlreadyCreatedCommonDirectories = CommonUnrealFunctions.CreateCommonDirectories(OutputDirectory, SourceDirectory, log);
}
Console.Write("\n");
if (ThisIsPreview || !ThisIsLogOnly)
{
//Check output directory exists, if not create the full html structure for this language
CommonUnrealFunctions.GenerateDocsFolderStructure(OutputDirectory, fileOutputDirectory, language);
CommonUnrealFunctions.SetFileAttributeForReplace(new FileInfo(targetFileName));
File.WriteAllText(targetFileName, output);
if (format == OutputFormat.PDF)
{
PdfHelper.CreatePdfFromHtml(targetFileName);
}
}
result = ConvertFileResponse.Converted;
}
}
}
return(result);
}
public string GetMarkDown()
{
var md = new MarkdownSharp.Markdown();
return(md.Transform(thispage.Post.PostContent));
}
public static string Summary(string content, int characters)
{
var md = new MarkdownSharp.Markdown();
return(md.Transform(GetUnTransformedSummary(content, characters)));
}
