private static JoinHtmlString PerformRender(MarkdownString markdownString, ILinkRenderer?linkRenderer,
Action <string, TextWriter, MarkdownPipeline, MarkdownParserContext> renderMethod, IHtmlSanitizer sanitizer)
{
linkRenderer ??= DoNothingLinkRenderer.Instance;
if (markdownString?.Contents == null)
{
return("".MarkAsHtmlString());
}
var context = new MarkdownParserContext();
var contents = sanitizer.Sanitize(markdownString.Contents);
//TODO - do we need to save re-use pipeline?
var pipeline = new MarkdownPipelineBuilder()
.UseSoftlineBreakAsHardlineBreak()
.UseMediaLinks()
.UseAutoLinks()
.UseEntityLinker(linkRenderer)
.Build();
var writer = new StringWriter();
renderMethod(contents, writer, pipeline, context);
var rendered = writer.ToString();
return(sanitizer.Sanitize(rendered).MarkAsHtmlString());
}
private FieldsChangedEmail(
Character character,
Claim claim,
User initiator,
ICollection <User> recipients,
[NotNull]
IReadOnlyCollection <FieldWithPreviousAndNewValue> updatedFields,
[CanBeNull]
IReadOnlyDictionary <string, PreviousAndNewValue> otherChangedAttributes)
{
if (character != null && claim != null)
{
throw new ArgumentException(
$"Both {nameof(character)} and {nameof(claim)} were provided");
}
if (character == null && claim == null)
{
throw new ArgumentException(
$"Neither {nameof(character)} nor {nameof(claim)} were provided");
}
Character = character;
Claim = claim;
ProjectName = character?.Project.ProjectName ?? claim?.Project.ProjectName;
Initiator = initiator;
Text = new MarkdownString();
Recipients = recipients;
UpdatedFields = updatedFields ?? throw new ArgumentNullException(nameof(updatedFields));
OtherChangedAttributes = otherChangedAttributes ?? new Dictionary <string, PreviousAndNewValue>();
}
public static JoinHtmlString ToHtmlString([CanBeNull]
this MarkdownString markdownString,
ILinkRenderer?renderer = null)
=> PerformRender(markdownString,
renderer,
(text, writer, pipeline, context) => Markdig.Markdown.ToHtml(text, writer, pipeline, context),
HtmlSanitizers.Simple);
public static IHtmlString ToHtmlString([CanBeNull]
this MarkdownString markdownString,
ILinkRenderer renderer = null)
=> PerformRender(markdownString,
renderer,
Markdig.Markdown.ToHtml,
HtmlSanitizers.Simple);
private async Task SendEmail(ICollection <User> recepients, string subject, string text, Recipient sender)
{
if (!recepients.Any())
{
return;
}
var html = new MarkdownString(text).ToHtmlString().ToHtmlString();
var message = new MessageBuilder().AddUsers(recepients)
.SetSubject(subject)
.SetFromAddress(new Recipient()
{
DisplayName = sender.DisplayName, Email = _joinRpgSender.Email
})
.SetReplyToAddress(sender)
.SetTextBody(text)
.SetHtmlBody(html)
.GetMessage();
message.RecipientVariables =
JObject.Parse("{" + string.Join(", ", recepients.Select(r => $"\"{r.Email}\":{{\"name\":\"{r.DisplayName}\"}}")) + "}");
if (_emailEnabled)
{
await Send(message);
}
}
//TODO: move character operations to a separate service.
public async Task EditCharacter(int currentUserId, int characterId, int projectId, string name, bool isPublic,
IReadOnlyCollection <int> parentCharacterGroupIds, bool isAcceptingClaims, string contents,
bool hidePlayerForCharacter, IDictionary <int, string> characterFields, bool isHot)
{
var character = await LoadProjectSubEntityAsync <Character>(projectId, characterId);
character.RequestMasterAccess(currentUserId, acl => acl.CanEditRoles);
character.EnsureProjectActive();
var changedAttributes = new Dictionary <string, PreviousAndNewValue>();
changedAttributes.Add("Имя персонажа", new PreviousAndNewValue(name, character.CharacterName.Trim()));
character.CharacterName = name.Trim();
character.IsAcceptingClaims = isAcceptingClaims;
character.IsPublic = isPublic;
var newDescription = new MarkdownString(contents);
changedAttributes.Add("Описание персонажа", new PreviousAndNewValue(newDescription, character.Description));
character.Description = newDescription;
character.HidePlayerForCharacter = hidePlayerForCharacter;
character.IsHot = isHot;
character.IsActive = true;
character.ParentCharacterGroupIds = await ValidateCharacterGroupList(projectId,
Required(parentCharacterGroupIds), ensureNotSpecial : true);
var changedFields = FieldSaveHelper.SaveCharacterFields(currentUserId, character, characterFields, FieldDefaultValueGenerator);
MarkChanged(character);
MarkTreeModified(character.Project); //TODO: Can be smarter
FieldsChangedEmail email = null;
changedAttributes = changedAttributes
.Where(attr => attr.Value.DisplayString != attr.Value.PreviousDisplayString)
.ToDictionary(x => x.Key, x => x.Value);
if (changedFields.Any() || changedAttributes.Any())
{
var user = await UserRepository.GetById(currentUserId);
email = EmailHelpers.CreateFieldsEmail(
character,
s => s.FieldChange,
user,
changedFields,
changedAttributes);
}
await UnitOfWork.SaveChangesAsync();
if (email != null)
{
await EmailService.Email(email);
}
}
public void CanBeAssignedFromString()
{
var source = "Gets or sets the background color of the console.";
MarkdownString ms = source;
ms.IsTrusted.Should().BeFalse();
ms.Value.Should().Be("Gets or sets the background color of the console.");
}
public static JoinHtmlString ToPlainText([CanBeNull]
this MarkdownString markdownString,
ILinkRenderer renderer = null)
=>
PerformRender(markdownString,
renderer,
(text, writer, pipeline, context) => Markdig.Markdown.ToPlainText(text, writer, pipeline, context),
HtmlSanitizers.RemoveAll);
public static IHtmlString ToPlainText([CanBeNull]
this MarkdownString markdownString,
ILinkRenderer renderer = null)
=>
PerformRender(markdownString,
renderer,
Markdig.Markdown.ToPlainText,
HtmlSanitizers.RemoveAll);
public static IHtmlString ToHtmlString([CanBeNull] this MarkdownString markdownString,
[NotNull] ILinkRenderer renderer)
{
if (renderer == null)
{
throw new ArgumentNullException(nameof(renderer));
}
return(markdownString?.Contents == null ? new HtmlString("") : markdownString.RenderMarkDownToHtmlUnsafe(renderer).SanitizeHtml());
}
public static Task SendEmail(this IEmailSendingService emailSendingService,
string subject,
MarkdownString body,
RecepientData sender,
RecepientData recepient)
=>
emailSendingService.SendEmails(subject,
body,
sender,
new[] { recepient, });
public FieldValueViewModel(CustomFieldsViewModel model, [NotNull] FieldWithValue ch, ILinkRenderer renderer)
{
if (ch == null)
{
throw new ArgumentNullException(nameof(ch));
}
Value = ch.Value;
if (ch.Field.SupportsMarkdown())
{
DisplayString = new MarkdownString(ch.DisplayString).ToHtmlString(renderer);
}
else
{
DisplayString = ch.DisplayString.SanitizeHtml();
}
FieldViewType = (ProjectFieldViewType)ch.Field.FieldType;
FieldName = ch.Field.FieldName;
Description = ch.Field.Description.ToHtmlString();
IsPlayerVisible = ch.Field.CanPlayerView;
IsDeleted = !ch.Field.IsActive;
HasValue = ch.HasValue || !ch.Field.CanHaveValue();
var hasViewAccess = ch.Field.IsPublic ||
model.HasMasterAccess
||
(model.HasPlayerAccessToCharacter && ch.Field.CanPlayerView &&
ch.Field.FieldBoundTo == FieldBoundTo.Character)
||
(model.HasPlayerClaimAccess && ch.Field.CanPlayerView &&
ch.Field.FieldBoundTo == FieldBoundTo.Claim);
CanView = hasViewAccess &&
(ch.HasValue || (!ch.Field.CanHaveValue() && ch.Field.IsAvailableForTarget(model.Target)));
CanEdit = model.EditAllowed &&
ch.HasEditAccess(
model.HasMasterAccess,
model.HasPlayerAccessToCharacter,
model.HasPlayerClaimAccess,
model.Target);
if (ch.Field.HasValueList())
{
ValueList = ch.GetDropdownValues().ToArray();
PossibleValueList = ch.GetPossibleValues();
}
ProjectFieldId = ch.Field.ProjectFieldId;
FieldBound = (FieldBoundToViewModel)ch.Field.FieldBoundTo;
MandatoryStatus = IsDeleted ? MandatoryStatusViewType.Optional : (MandatoryStatusViewType)ch.Field.MandatoryStatus;
}
public override bool IsValid(object value)
{
if (value == null)
{
return(!Optional);
}
MarkdownString mdString = (MarkdownString)value;
return(mdString.Length >= MinimumLength && mdString.Length <= MaximumLength);
}
public static string ToPlainText([CanBeNull] this MarkdownString markdownString, [NotNull] ILinkRenderer renderer)
{
if (renderer == null)
{
throw new ArgumentNullException(nameof(renderer));
}
if (markdownString?.Contents == null)
{
return("");
}
return(markdownString.RenderMarkDownToHtmlUnsafe(renderer).RemoveHtml().Trim());
}
public static MarkdownString TakeWords(this MarkdownString markdownString, int words)
{
if (markdownString?.Contents == null)
{
return(null);
}
var w = words;
var idx = markdownString.Contents.TakeWhile(c => (w -= char.IsWhiteSpace(c) ? 1 : 0) > 0 && c != '\n').Count();
var mdContents = markdownString.Contents.Substring(0, idx);
return(new MarkdownString(mdContents));
}
public ActionResult Help(string SearchTerm = "", bool IncludeInGame = true)
{
List <IHelp> validEntries = TemplateCache.GetAll <IHelp>(true).ToList();
ApplicationUser user = null;
string searcher = SearchTerm.Trim().ToLower();
if (User.Identity.IsAuthenticated)
{
user = UserManager.FindById(User.Identity.GetUserId());
StaffRank userRank = user.GetStaffRank(User);
}
if (IncludeInGame)
{
//All the entities with helps
IEnumerable <ILookupData> entityHelps = TemplateCache.GetAll <ILookupData>(true).Where(data => !data.ImplementsType <IHelp>());
validEntries.AddRange(entityHelps.Select(helpful => new Data.Administrative.Help()
{
Name = helpful.Name, HelpText = helpful.HelpText
}));
//All the commands
Assembly commandsAssembly = Assembly.GetAssembly(typeof(CommandParameterAttribute));
IEnumerable <Type> validTargetTypes = commandsAssembly.GetTypes().Where(t => !t.IsAbstract && t.ImplementsType <IHelpful>());
foreach (Type command in validTargetTypes)
{
IHelpful instance = (IHelpful)Activator.CreateInstance(command);
MarkdownString body = instance.HelpText;
string subject = command.Name;
validEntries.Add(new Data.Administrative.Help()
{
Name = subject, HelpText = body
});
}
}
HelpViewModel vModel = new HelpViewModel(validEntries.Where(help => help.HelpText.ToLower().Contains(searcher) || help.Name.ToLower().Contains(searcher)))
{
AuthedUser = user,
SearchTerm = SearchTerm,
IncludeInGame = IncludeInGame
};
return(View(vModel));
}
public async Task SendEmails(string subject, MarkdownString body, RecepientData sender, IReadOnlyCollection <RecepientData> to)
{
if (!to.Any())
{
return;
}
var html = body.ToHtmlString().ToHtmlString();
var text = body.ToPlainText().ToString();
for (var i = 0; i *Constants.MaxRecipientsInChunk < to.Count; i++)
{
await SendEmailChunkImpl(
to.Skip(i *Constants.MaxRecipientsInChunk).Take(Constants.MaxRecipientsInChunk).ToList(),
subject, text, sender, html);
}
}
private static UnSafeHtml RenderMarkDownToHtmlUnsafe(this MarkdownString markdownString,
[NotNull] ILinkRenderer renderer)
{
if (renderer == null)
{
throw new ArgumentNullException(nameof(renderer));
}
//TODO - do we need to save re-use pipeline?
var pipeline =
new MarkdownPipelineBuilder()
.UseSoftlineBreakAsHardlineBreak()
.UseAutoLinks()
.UseEntityLinker(renderer)
.Build();
return(Markdig.Markdown.ToHtml(markdownString.Contents, pipeline));
}
private FieldsChangedEmail(
Character?character,
Claim?claim,
User initiator,
ICollection <User> recipients,
[NotNull]
IReadOnlyCollection <FieldWithPreviousAndNewValue> updatedFields,
[CanBeNull]
IReadOnlyDictionary <string, PreviousAndNewValue>?otherChangedAttributes)
{
if (character != null && claim != null)
{
throw new ArgumentException(
$"Both {nameof(character)} and {nameof(claim)} were provided");
}
else if (claim != null)
{
FieldsContainer = claim;
Linkable = claim;
ProjectName = claim.Project.ProjectName;
Claim = claim;
Name = claim.Name;
}
else if (character != null)
{
FieldsContainer = character;
Linkable = character;
ProjectName = character.Project.ProjectName;
Claim = character.ApprovedClaim;
Name = character.CharacterName;
IsCharacterMail = true;
}
else
{
throw new ArgumentException(
$"Neither {nameof(character)} nor {nameof(claim)} were provided");
}
Initiator = initiator;
Text = new MarkdownString();
Recipients = recipients;
UpdatedFields = updatedFields ?? throw new ArgumentNullException(nameof(updatedFields));
OtherChangedAttributes = otherChangedAttributes ?? new Dictionary <string, PreviousAndNewValue>();
}
public async Task <IReadOnlyCollection <ISearchResult> > SearchAsync(int?currentUserId, string searchString)
{
bool matchByIdIsPerfect;
int? idToFind = SearchKeywordsResolver.TryGetId(
searchString,
keysForPerfectMath,
out matchByIdIsPerfect);
var results =
await
UnitOfWork.GetDbSet <User>()
.Where(user =>
//TODO There should be magic way to do this. Experiment with Expression.Voodoo
user.UserId == idToFind ||
user.Email.Contains(searchString) ||
user.FatherName.Contains(searchString) ||
user.BornName.Contains(searchString) ||
user.SurName.Contains(searchString) ||
user.PrefferedName.Contains(searchString) ||
(user.Extra != null && user.Extra.Nicknames != null && user.Extra.Nicknames.Contains(searchString))
)
.ToListAsync();
return(results.Select(user =>
{
bool wasfoundById = user.UserId == idToFind;
var description = new MarkdownString(wasfoundById
? WorldObjectProviderBase.GetFoundByIdDescription(user.UserId)
: "");
return new SearchResultImpl
{
LinkType = LinkType.ResultUser,
Name = user.GetDisplayName(),
Description = description,
Identification = user.UserId.ToString(),
ProjectId = null, //Users not associated with any project
IsPublic = true,
IsActive = true,
IsPerfectMatch = wasfoundById && matchByIdIsPerfect,
};
}).ToList());
}
private async Task SendEmail(
ICollection <MailRecipient> recipients,
string subject,
string text,
Recipient sender)
{
if (!recipients.Any())
{
return;
}
var html = new MarkdownString(text).ToHtmlString().ToHtmlString();
for (var i = 0; i *MaxRecipientsInChunk < recipients.Count; i++)
{
await SendEmailChunkImpl(recipients.Skip(i *MaxRecipientsInChunk).Take(MaxRecipientsInChunk).ToList(), subject,
text, sender, html);
}
}
/// <summary>
/// How to check against this result; returns true if it passes integrity
/// </summary>
internal override bool Verify(object val)
{
string compareValue = "";
if (val != null && val.GetType() == typeof(MarkdownString))
{
MarkdownString mdString = Utility.DataUtility.TryConvert <MarkdownString>(val);
if (!MarkdownString.IsNullOrWhiteSpace(mdString))
{
compareValue = mdString.Value;
}
}
else
{
compareValue = Utility.DataUtility.TryConvert <string>(val);
}
return(!string.IsNullOrWhiteSpace(compareValue) && compareValue.Length >= MinimumLength && compareValue.Length <= MaximumLength);
}
private static IHtmlString PerformRender(MarkdownString markdownString, ILinkRenderer linkRenderer,
Func <string, MarkdownPipeline, string> renderMethod, IHtmlSanitizer sanitizer)
{
linkRenderer = linkRenderer ?? DoNothingLinkRenderer.Instance;
if (markdownString?.Contents == null)
{
return(new HtmlString(""));
}
var contents = sanitizer.Sanitize(markdownString.Contents);
//TODO - do we need to save re-use pipeline?
var pipeline = new MarkdownPipelineBuilder()
.UseSoftlineBreakAsHardlineBreak()
.UseAutoLinks()
.UseEntityLinker(linkRenderer)
.Build();
return(new HtmlString(sanitizer.Sanitize(renderMethod(contents, pipeline))));
}
private void TestMarkdown(string markdown, string expectedHtml)
{
var actualHtml = new MarkdownString(markdown).ToHtmlString().ToHtmlString();
Assert.AreEqual(expectedHtml, actualHtml);
}
/// <summary>
/// Return diffs between 2 strings.
/// TODO: not implemented yet
/// </summary>
public static MarkdownString HighlightDiffPlaceholder(MarkdownString newString,
MarkdownString oldString) =>
//TODO: look for diff algorithms
newString;
private void Match(string expected, string original)
{
var result = new MarkdownString(original).ToHtmlString(_mock);
Assert.AreEqual(expected, result.ToString());
}
private void NoMatch(string contents)
{
var result = new MarkdownString(contents).ToPlainText(_mock);
Assert.AreEqual(contents, result.ToHtmlString());
}
public ProjectPluginConfiguraton(string name, MarkdownString configuration)
{
Name = name;
Configuration = configuration;
}
public PreviousAndNewValue(string newValue, string previousValue)
{
DisplayString = new MarkdownString(newValue);
PreviousDisplayString = new MarkdownString(previousValue);
}
public PreviousAndNewValue(MarkdownString newValue, MarkdownString previousValue)
{
DisplayString = newValue;
PreviousDisplayString = previousValue;
}
