public FeatureViewModel(Feature feature) { Text = MarkdownHelper.Markdown(feature.Text.ConvertingLinksToMarkdownUrls()); FriendlyTime = feature.Time.ToFriendly(); Author = feature.User.UserName; GravatarUrl = (string.IsNullOrEmpty(feature.User.AvatarUrl)) ? feature.User.Email.ToGravatarUrl(40) : feature.User.AvatarUrl; }
private static async Task GetLatest(bool rebuildTable) { if (rebuildTable) { List <Service> onlineServiceList = await HtmlHelper.ParseAwsServices("https://aws.amazon.com/products/"); List <Service> master = ServiceListHelper.OrderServiceListByShortName(onlineServiceList); await DynamoHelper.RebuildTable(master); List <Service> serviceList = await DynamoHelper.QueryTable(); List <Tags> tagList = await HtmlHelper.ParseBlogTags("https://msimpson.co.nz/tags/aws/"); List <TableEntry> tableList = MarkdownHelper.BuildTable(serviceList, tagList); MarkdownHelper.BuildMarkdown(tableList); } else { List <Service> serviceList = await DynamoHelper.QueryTable(); List <Tags> tagList = await HtmlHelper.ParseBlogTags("https://msimpson.co.nz/tags/aws/"); List <TableEntry> tableList = MarkdownHelper.BuildTable(serviceList, tagList); MarkdownHelper.BuildMarkdown(tableList); } }
public async void SendNewMessageNoticeToChatUsersAsync(MessageDto newMessage, ClientConnection connection, bool sendPush = true) { try { List <ChatUserVm> chatUsers = await loadChatsService.GetChatUsersAsync(newMessage.ConversationId, null).ConfigureAwait(false); if (sendPush) { pushNotificationsService.SendMessageNotificationAsync( newMessage, chatUsers.Select(opt => new NotificationUser(opt.UserId, opt.IsMuted.Value)).ToList()); } List <Task> noticeTasks = new List <Task>(); foreach (var chatUser in chatUsers) { var clientConnections = connectionsService.GetUserClientConnections(chatUser.UserId); if (clientConnections != null) { noticeTasks.Add(Task.Run(async() => { NewMessageNotice notice = new NewMessageNotice( MessageConverter.GetMessageVm(newMessage, chatUser.UserId), MarkdownHelper.ContainsMarkdownUserCalling(newMessage.Text, chatUser.UserId)); await SendNoticeToClientsAsync(clientConnections.Where(clientConnection => clientConnection != connection), notice).ConfigureAwait(false); })); } } await Task.WhenAll(noticeTasks).ConfigureAwait(false); } catch (Exception ex) { Logger.WriteLog(ex); } }
private static void GenerateFilePerClass(MarkdownBuilder homeBuilder, string dest, MarkdownableType[] types) { foreach (var g in types.GroupBy(x => x.Namespace).OrderBy(x => x.Key)) { string namespacePath = Path.Combine(dest, g.Key); homeBuilder.Header(2, g.Key); homeBuilder.AppendLine(); if (!Directory.Exists(namespacePath)) { Directory.CreateDirectory(namespacePath); } foreach (var item in g.OrderBy(x => x.Name)) { var sb = new StringBuilder(); homeBuilder.ListLink(MarkdownHelper.RenderCode(item.DisplayName), g.Key + "/" + item.ProcessedName); sb.Append(item.ToString()); File.WriteAllText(Path.Combine(namespacePath, item.ProcessedName + ".md"), sb.ToString()); } homeBuilder.AppendLine(); } }
public FeatureViewModel(Feature feature) { Text = MarkdownHelper.Markdown(feature.Text); FriendlyTime = FriendlyTimeHelper.Parse(feature.Time); Author = feature.User.UserName; GravatarUrl = (string.IsNullOrEmpty(feature.User.AvatarUrl)) ? feature.User.Email.ToGravatarUrl(40) : feature.User.AvatarUrl; }
string GetAboutText(string htmlAbout) { if (!string.IsNullOrEmpty(htmlAbout)) { return(HtmlUtils.StripTags(MarkdownHelper.PreprocessHtml(HttpUtility.HtmlDecode(HttpUtility.HtmlDecode(htmlAbout))), true)); } return(null); }
public override IEnumerable <string> GetWriteLines(string readMeFilePath) { var url = FullPath.Replace(readMeFilePath, "").Replace('\\', '/').Replace(" ", "%20").TrimStart('/'); yield return(MarkdownHelper.LinkRowInner(Name, url)); yield return(null); }
public HomeModule(IIdeaRepository ideas, ISettingsRepository settings) { Get["/"] = _ => View["Home/Index", new { Ideas = ideas.GetAll(), Title = settings.Title, WelcomeMessage = MarkdownHelper.Markdown(settings.WelcomeMessage) }]; }
public async Task <IncidentBasePayload> AddIncidentAsync(AddIncidentInput input, [ScopedService] ApplicationDbContext context, [FromServices] IFluentEmail email, CancellationToken cancellationToken) { DateTime?endedAt = null; if (input.EndedAt.HasValue) { endedAt = input.EndedAt; } var incident = new Incident { Title = input.Title, Description = input.Description !, DescriptionHtml = MarkdownHelper.ToHtml(input.Description), Service = await context.Service.DeferredFirst(x => x.Id == input.ServiceId).FromCacheAsync(cancellationToken), StartedAt = input.StartedAt, EndedAt = endedAt, Author = await context.User.DeferredFirst(x => x.Id == Int32.Parse(_httpContextAccessor.HttpContext !.User.FindFirst(ClaimTypes.Name) !.Value)).FromCacheAsync(cancellationToken) }; await context.Incident.AddAsync(incident, cancellationToken); await context.SaveChangesAsync(cancellationToken); var template = await context.Settings.Where(x => x.Key == "backend.email.template.incident.create").DeferredFirst().FromCacheAsync(cancellationToken); var emailDomain = await context.Settings.Where(x => x.Key == "backend.email.domain").DeferredFirst().FromCacheAsync(cancellationToken); try { await context.Subscriber.ForEachAsync((subscriber) => { if (!template.Value.IsNullOrEmpty()) { email.To(subscriber.Email).Subject($"Incident Created: {incident.Service.Name}").UsingTemplate(template.Value, new { Title = incident.Title, Description = incident.Description, ServiceName = incident.Service.Name, StartedAd = incident.StartedAt.ToString(CultureInfo.InvariantCulture), EndedAt = incident.EndedAt?.ToString(CultureInfo.InvariantCulture), Attachements = incident.Files }); // We set the message ID so we can reference it in status updates and what not. email.Header("Message-ID", $"<{incident.Id}@{emailDomain.Value}>"); email.Send(); } }, cancellationToken); } catch (Exception e) { Console.WriteLine(e.Message); } QueryCacheManager.ExpireType <Incident>(); return(new IncidentBasePayload(incident)); }
/// <summary> /// 获取readme.md的头部信息 /// </summary> /// <returns></returns> private IEnumerable <string> GetHeaderInfos() { var heading = ConfigHelper.GetAppSettingValue("Heading"); yield return(null); yield return(MarkdownHelper.Heading1(heading)); yield return(null); }
public void ConvertToMarkDownTest() { // Convert good var html = "Something to <strong>convert</strong>"; string md = MarkdownHelper.ConvertToMarkDown(html); int i = 0; // Html2Markdown return always same as input string html = "<!--StartFragment--><span style=\"color: rgb(0, 0, 128); font - family: Arial, Helvetica, sans - serif; font - size: 16px; font - style: normal; font - variant - ligatures: normal; font - variant - caps: normal; font - weight: 400; letter - spacing: normal; orphans: 2; text - align: start; text - indent: 0px; text - transform: none; white - space: normal; widows: 2; word - spacing: 0px; -webkit - text - stroke - width: 0px; background - color: rgb(255, 255, 255); text - decoration - style: initial; text - decoration - color: initial; display: inline !important; float: none; \">They<span>�</span></span><strong style=\"color: rgb(0, 0, 128); font - family: Arial, Helvetica, sans - serif; font - size: 16px; font - style: normal; font - variant - ligatures: normal; font - variant - caps: normal; letter - spacing: normal; orphans: 2; text - align: start; text - indent: 0px; text - transform: none; white - space: normal; widows: 2; word - spacing: 0px; -webkit - text - stroke - width: 0px; background - color: rgb(255, 255, 255); text - decoration - style: initial; text - decoration - color: initial; \">will have completed</strong><span style=\"color: rgb(0, 0, 128); font - family: Arial, Helvetica, sans - serif; font - size: 16px; font - style: normal; font - variant - ligatures: normal; font - variant - caps: normal; font - weight: 400; letter - spacing: normal; orphans: 2; text - align: start; text - indent: 0px; text - transform: none; white - space: normal; widows: 2; word - spacing: 0px; -webkit - text - stroke - width: 0px; background - color: rgb(255, 255, 255); text - decoration - style: initial; text - decoration - color: initial; display: inline !important; float: none; \"><span>�</span>the project before the deadline.</span><!--EndFragment-->"; }
public ActionResult MessageBody(int messageId = invalidId) { if (messageId == invalidId) { return(NoId()); } var msg = messageQueries.Get(messageId, null); var body = MarkdownHelper.TranformMarkdown(msg.Body); return(Content(body)); }
public List <string> SendKickerToMarkdown( PlayerReportModel playerModel, int[] weeksOfInterest = null, bool sendToObsidian = false) { var line = new List <string>(); if (weeksOfInterest == null) { weeksOfInterest = new int[] { 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16 } } ; line.Add($"{playerModel.PlayerName} {playerModel.Season}"); line.Add(string.Empty); var totals = new GameStats(); var grandtotals = new GameStats(); var isFirst = false; foreach (var game in playerModel.GameLog) { if (weeksOfInterest.Contains( game.Week)) { if (isFirst && (game.Week.Equals(5) || game.Week.Equals(9) || game.Week.Equals(13))) { WriteKickerTotalLine(totals, line); totals = new GameStats(); Console.WriteLine(); } line.Add($" {game.KickerStats()}"); totals.FieldGoalsMade += game.FieldGoalsMade; totals.ExtraPointsMade += game.ExtraPointsMade; grandtotals.FieldGoalsMade += game.FieldGoalsMade; grandtotals.ExtraPointsMade += game.ExtraPointsMade; isFirst = true; } } WriteKickerTotalLine(totals, line); line.Add(string.Empty); WriteKickerTotalLine(grandtotals, line); line.Add(string.Empty); if (sendToObsidian) { var fileName = $"{playerModel.PlayerName} {playerModel.Season}"; MarkdownHelper.SendToObsidian( line, fileName); } return(line); }
public ActivityViewModel(Activity activity) { FriendlyTime = FriendlyTimeHelper.Parse(activity.Time); var comment = activity as Comment; if (comment != null) { Text = MarkdownHelper.Markdown(comment.Text); // TODO: not hard code these Author = activity.User.UserName; GravatarUrl = (string.IsNullOrEmpty(activity.User.AvatarUrl)) ? activity.User.Email.ToGravatarUrl(40) : activity.User.AvatarUrl; } }
public ActionResult MessageBody(int messageId = invalidId) { if (messageId == invalidId) { return(NoId()); } var msg = messageQueries.Get(messageId, null); //return PartialView("Message", messageQueries.Get(messageId, new GravatarUserIconFactory(20))); //return LowercaseJson(msg); var body = MarkdownHelper.TranformMarkdown(msg.Body); return(Content(body)); }
public override async Task ProcessAsync(TagHelperContext context, TagHelperOutput output) { if (output.TagName == "markdown") { output.TagName = null; } var content = await GetContent(output); var markdown = content; var html = MarkdownHelper.CoventToHtml(markdown); output.Content.SetHtmlContent(html.Value); }
public async Task Podcast() { Response.ContentType = "application/rss+xml"; List <SyndicationItem> items = new List <SyndicationItem>(); List <Podcast.Models.Podcast> podcasts = _dbContext.Podcasts.Where(p => p.Published).OrderByDescending(p => p.Episode).ToList(); if (podcasts != null) { foreach (Podcast.Models.Podcast podcast in podcasts) { SyndicationItem item = new SyndicationItem() { Id = podcast.Episode.ToString(), Title = podcast.Title, Description = MarkdownHelper.Markdown(podcast.Description).Value, Published = podcast.DatePublished }; item.AddLink(new SyndicationLink(new Uri(Url.SubRouteUrl("podcast", "Podcast.View", new { episode = podcast.Episode })))); foreach (Podcast.Models.PodcastFile file in podcast.Files) { SyndicationLink enclosure = new SyndicationLink(new Uri(Url.SubRouteUrl("podcast", "Podcast.Download", new { episode = podcast.Episode, fileName = file.FileName }))); item.AddLink(enclosure); } items.Add(item); } } using (var xmlWriter = CreateXmlWriter()) { var feedWriter = new RssFeedWriter(xmlWriter); await feedWriter.WriteTitle(_config.PodcastConfig.Title); await feedWriter.WriteDescription(_config.PodcastConfig.Description); await feedWriter.Write(new SyndicationLink(new Uri(Url.SubRouteUrl("podcast", "Podcast.Index")))); foreach (SyndicationItem item in items) { await feedWriter.Write(item); } await xmlWriter.FlushAsync(); } }
public void CreateReport_Notify_ReportTypeNameAndNotes() { var editor = user2; repository.Save(ArchivedSongVersion.Create(song, new SongDiff(), new AgentLoginData(editor), SongArchiveReason.PropertiesUpdated, String.Empty)); queries.CreateReport(song.Id, SongReportType.BrokenPV, "39.39.39.39", "It's Miku, not Rin", null); var entryLink = MarkdownHelper.CreateMarkdownLink(entryLinkFactory.GetFullEntryUrl(song), song.DefaultName); var notification = repository.List <UserMessage>().FirstOrDefault(); Assert.IsNotNull(notification, "notification was created"); Assert.AreEqual(string.Format(EntryReportStrings.EntryVersionReportTitle, song.DefaultName), notification.Subject, "Notification subject"); Assert.AreEqual(string.Format(EntryReportStrings.EntryVersionReportBody, entryLink, "Broken PV (It's Miku, not Rin)"), notification.Message, "Notification body"); }
public MappingProfile() { SlugHelper helper = new SlugHelper(); CreateMap <WikiPageEntity, WikiPageDTO>() .ForMember(dest => dest.BodyMarkDown, (expr) => expr.MapFrom <string>(x => x.Body)) .ForMember(dest => dest.BodyHtml, (expr) => expr.MapFrom <string>(x => MarkdownHelper.ConvertToHtml(x.Body))) .ReverseMap(); CreateMap <WikiPageBO, WikiPageEntity>() .ForMember(dest => dest.Body, (expr) => expr.MapFrom <string>(x => x.BodyMarkDown)) .ForMember(dest => dest.Slug, (expr) => expr.MapFrom <string>(x => helper.GenerateSlug(x.Title))); }
public IdeaViewModel(Idea idea) { Id = idea.Id; Title = idea.Title; Status = idea.Status; Time = idea.Time; Description = MarkdownHelper.Markdown(idea.Description); UserHasVoted = idea.UserHasVoted; TotalVotes = idea.Votes.Count; Author = idea.Author; GravatarUrl = (string.IsNullOrEmpty(Author.AvatarUrl)) ? Author.Email.ToGravatarUrl(40) : Author.AvatarUrl; Features = idea.Features.Select(f => new FeatureViewModel(f)).ToList(); Activities = idea.Activities.Select(f => new ActivityViewModel(f)).ToList(); Images = idea.Images.ToList(); }
private async Task SendChannelMessageNotificationAsyhc(MessageDto message, List <NotificationUser> notificationsUsers) { try { var administratorsChannel = await loadChannelsService.GetAdministrationChannelUsersAsync(message.ConversationId).ConfigureAwait(false); IEnumerable <TokenVm> tokens = await tokensService.GetAllUsersTokensAsync( notificationsUsers.Where(user => user.UserId != message.SenderId).Select(user => user.UserId)).ConfigureAwait(false); foreach (var user in notificationsUsers) { bool isCall = MarkdownHelper.ContainsMarkdownUserCalling(message.Text, user.UserId); var userTokens = GetOfflineUserTokens(tokens.ToList(), user.UserId); List <TokenVm> adminTokens = tokens.Where(token => administratorsChannel.Any(admin => admin.UserId == token.UserId))?.ToList(); if (adminTokens != null && adminTokens.Any()) { adminTokens = GetOfflineUserTokens(adminTokens, user.UserId); var messageVm = MessageConverter.GetMessageVm(message, user.UserId); if (messageVm.Attachments?.Any(attach => attach.Type == AttachmentType.EncryptedMessage) ?? false) { messageVm.Attachments = null; } if (adminTokens != null && (!user.IsMuted || isCall)) { await SendNotificationRequestAsync( adminTokens.Select(opt => opt.DeviceTokenId), new NewMessageNotice(messageVm, isCall)) .ConfigureAwait(false); } } else if (!user.IsMuted || isCall) { MessageVm subMessage = MessageConverter.GetMessageVm(message, user.UserId); subMessage.SenderId = null; await SendNotificationRequestAsync( userTokens.Select(opt => opt.DeviceTokenId), new NewMessageNotice(subMessage, isCall)) .ConfigureAwait(false); } } } catch (Exception ex) { Logger.WriteLog(ex); } }
public override IEnumerable <string> GetWriteLines(string readMeFilePath) { if (LinkInfos.Count > 0) { yield return(MarkdownHelper.Heading2(Name)); yield return(null); foreach (var linkInfo in LinkInfos) { foreach (var item in linkInfo.GetWriteLines(readMeFilePath)) { yield return(item); } } } }
public async void SendNewMessageNoticeToChannelUsersAsync(MessageDto newMessage, ClientConnection clientConnection = null, bool sendPush = true) { try { var channelUsers = await loadChannelsService.GetChannelUsersAsync(newMessage.ConversationId, null, null).ConfigureAwait(false); if (sendPush) { pushNotificationsService.SendMessageNotificationAsync( newMessage, channelUsers.Select(opt => new NotificationUser(opt.UserId, opt.IsMuted.Value)).ToList()); } var administrationUsers = await loadChannelsService.GetAdministrationChannelUsersAsync(newMessage.ConversationId).ConfigureAwait(false); foreach (var channelUser in channelUsers) { var clientConnections = connectionsService.GetUserClientConnections(channelUser.UserId); if (clientConnections != null) { clientConnections = clientConnections.Where(opt => opt != clientConnection).ToList(); NewMessageNotice notice; if (channelUser.UserId == newMessage.SenderId || administrationUsers.Any(opt => opt.UserId == channelUser.UserId)) { notice = new NewMessageNotice( MessageConverter.GetMessageVm(newMessage, channelUser.UserId), MarkdownHelper.ContainsMarkdownUserCalling(newMessage.Text, channelUser.UserId)); } else { MessageVm tempMessage = new MessageVm(MessageConverter.GetMessageVm(newMessage, channelUser.UserId)) { SenderId = null }; notice = new NewMessageNotice( tempMessage, MarkdownHelper.ContainsMarkdownUserCalling(tempMessage.Text, channelUser.UserId)); } await SendNoticeToClientsAsync(clientConnections, notice).ConfigureAwait(false); } } } catch (Exception ex) { Logger.WriteLog(ex); } }
public async Task <IncidentMessageBasePayload> UpdateIncidentMessage(UpdateIncidentMessageInput input, [ScopedService] ApplicationDbContext context, CancellationToken cancellationToken) { var incidentMessage = await context.IncidentMessage .Include(x => x.Incident) .ThenInclude(x => x.Service) .DeferredFirst(x => x.Id == input.MessageId).FromCacheAsync(cancellationToken); if (incidentMessage is null) { return(new IncidentMessageBasePayload( new UserError("Incident with that id not found.", "INCIDENT_MESSAGE_NOT_FOUND"))); } if (input.StatusId.HasValue) { var status = await context.Status.DeferredFirst(x => x.Id == input.StatusId).FromCacheAsync(cancellationToken); incidentMessage.Status = status; incidentMessage.Incident.Service.Status = status; } if (input.Message.HasValue) { incidentMessage.Message = input.Message !; incidentMessage.MessageHtml = MarkdownHelper.ToHtml(input.Message); } if (input.IncidentId.HasValue) { var incident = await context.Incident.DeferredFirst(x => x.Id == input.IncidentId).FromCacheAsync(cancellationToken); incidentMessage.Incident = incident; } if (input.AttachedFilesIds.HasValue) { incidentMessage.Attachments = await addAttachments(input.AttachedFilesIds.Value, context, cancellationToken);; } await context.BulkSaveChangesAsync(cancellationToken); QueryCacheManager.ExpireType <IncidentMessage>(); return(new IncidentMessageBasePayload(incidentMessage)); }
private static void GenerateFilePerNamespace(MarkdownBuilder homeBuilder, string dest, MarkdownableType[] types) { foreach (var g in types.GroupBy(x => x.Namespace).OrderBy(x => x.Key)) { homeBuilder.HeaderWithLink(2, g.Key, g.Key); homeBuilder.AppendLine(); var sb = new StringBuilder(); foreach (var item in g.OrderBy(x => x.Name)) { homeBuilder.ListLink(MarkdownHelper.RenderCode(item.DisplayName), g.Key + "#" + item.ProcessedName.ToLower()); sb.Append(item.ToString()); } File.WriteAllText(Path.Combine(dest, g.Key + ".md"), sb.ToString()); homeBuilder.AppendLine(); } }
/// <summary> /// Implements the logic for <see cref="LoadDocsCommand"/>. /// </summary> /// <param name="name">The name of the docs file to load.</param> private async Task LoadDocsAsync(string name) { // Skip if the loading has already started if (!(LoadDocsCommand.ExecutionTask is null)) { return; } var path = Path.Combine(FilesServices.InstallationPath, "Assets", "docs", $"{name}.md"); using var stream = await FilesServices.OpenForReadAsync(path); using var reader = new StreamReader(stream); var text = await reader.ReadToEndAsync(); texts = MarkdownHelper.GetParagraphs(text); OnPropertyChanged(nameof(GetParagraph)); }
public Query(IBooksDataSource booksDataSource) { Name = "Query"; Field <BookType>( "book", arguments: new QueryArguments( new QueryArgument <NonNullGraphType <IdGraphType> > { Name = "id", Description = "id of the book" } ), resolve: context => booksDataSource.GetBook(context.GetArgument <int>("id")) ); Field <StringGraphType>( "source", arguments: new QueryArguments( new QueryArgument <NonNullGraphType <IdGraphType> > { Name = "id", Description = "id of the markdown source" } ), resolve: context => MarkdownHelper.GetMarkdown(context.GetArgument <string>("id")) ); Field <ListGraphType <BookType> >( "books", arguments: new QueryArguments( new QueryArgument <IntGraphType> { Name = "from", Description = "first pagination index" }, new QueryArgument <IntGraphType> { Name = "to", Description = "last pagination index" } ), resolve: context => booksDataSource.GetBooks() ); Field <IntGraphType>( "total", resolve: context => booksDataSource.GetBooks().Count ); }
public string GetTableOfContents(IEnumerable <HeaderSet> headers) { var strBuilder = new StringBuilder(); foreach (var header in headers) { if (header.Heading > 1) { strBuilder.Append(new String(' ', (header.Heading - 1) * 2)); } strBuilder.Append("*"); strBuilder.Append(" " + MarkdownHelper.GetLinkFromAnchor(header.Text, header.GetAnchorLink())); if (header != headers.LastOrDefault()) { strBuilder.AppendLine(); } } return(strBuilder.ToString()); }
//static void AppendIf(StringBuilder sb, string category, string? value) //{ // if (!value.IsNullOrEmpty()) // sb.AppendLine($"|**{category}**|{value}|"); //} static string RenderService(IDocument document, Package package, PackageService service) { var tabGroup = BuildTabGroup(package, service); var contentBuilder = new StringBuilder(); contentBuilder.AppendLine("<div class=\"tab-wrap\">"); var first = true; foreach (var tab in tabGroup.Tabs) { contentBuilder.AppendLine($"<input type=\"radio\" id=\"{tabGroup.Id}-{tab.Id}\" name=\"{tabGroup.Id}\" class=\"tab\" {(first ? "checked" : string.Empty)}><label for=\"{tabGroup.Id}-{tab.Id}\" >{tab.Name}</label>"); first = false; } foreach (var tab in tabGroup.Tabs) { contentBuilder.AppendLine("<div class=\"tab__content\">"); contentBuilder.AppendLine(); using (var writer = new StringWriter()) { MarkdownHelper.RenderMarkdown( document, tab.Content, writer, false, //prependLinkRoot "common", //configuration, null ); contentBuilder.AppendLine(writer.ToString()); } contentBuilder.AppendLine(); contentBuilder.AppendLine("</div>"); } contentBuilder.AppendLine("</div>"); return(contentBuilder.ToString()); }
public void CreateReport_Version() { var version = ArchivedSongVersion.Create(song, new SongDiff(), new AgentLoginData(user), SongArchiveReason.PropertiesUpdated, String.Empty); repository.Save(version); CallCreateReport(SongReportType.Other, version.Version); var report = repository.List <SongReport>().First(); Assert.AreEqual(version.Version, report.VersionNumber, "Version number"); Assert.IsNotNull(report.VersionBase, "VersionBase"); var notification = repository.List <UserMessage>().FirstOrDefault(); Assert.IsNotNull(notification, "Notification was created"); Assert.AreEqual(user, notification.Receiver, "Notification receiver"); Assert.AreEqual(string.Format(EntryReportStrings.EntryVersionReportTitle, song.DefaultName), notification.Subject, "Notification subject"); Assert.AreEqual(string.Format(EntryReportStrings.EntryVersionReportBody, MarkdownHelper.CreateMarkdownLink(entryLinkFactory.GetFullEntryUrl(song), song.DefaultName), "It's Miku, not Rin"), notification.Message, "Notification message"); }