private static bool InternalCanMergeAs <T>(
this IEnumerable <object> sources,
bool allowFuzzy,
bool throwOnError,
out MergeDictionary <string, object> merged
)
{
merged = MergeObjects(sources, allowFuzzy);
return(merged.InternalCanDuckAs <T>(allowFuzzy, throwOnError));
}
public static string GetMergeType(GMergeType type)
{
string result;
if (MergeDictionary.TryGetValue(type, out result))
{
return(result);
}
return("");
}
public async Task <IStatusCodeActionResult> Register([FromBody] RegisterViewModel model)
{
if (!ModelState.IsValid)
{
return(BadRequest(new { Succeeded = false, Errors = ModelState.Select(n => $"{n.Key}: {string.Join(',', n.Value.Errors.Select(m => m.ErrorMessage))}") }));
}
var user = new TUser
{
UserName = model.UserName,
Email = model.Email
};
var result = await UserManager.CreateAsync(user, model.Password);
if (result.Succeeded)
{
var code = await UserManager.GenerateEmailConfirmationTokenAsync(user);
var callbackUrl = $"{RegisterConfiguration.ApiConfirmationUrl}?userid={user.Id}&code={HttpUtility.UrlEncode(code)}";
var values = new MergeDictionary {
{ "Email", model.Email },
{ "UserName", model.UserName },
{ "ConfirmUserUrl", callbackUrl }
};
var message = await EmailRenderer.GenerateEmail("NewUser", model.Email, values);
await EmailSender.SendEmailAsync(message.ToEmail, message.Subject, message.BodyHtml ?? message.BodyPlainText);
//await EmailSender.SendEmailAsync(model.Email, Localizer["ConfirmEmailTitle"], Localizer["ConfirmEmailBody", callbackUrl]);
await SignInManager.SignInAsync(user, isPersistent : false);
if (!string.IsNullOrWhiteSpace(RegisterConfiguration.NewUserDefaultRole) && UserManager.SupportsUserRole)
{
string[] roles = RegisterConfiguration.NewUserDefaultRole.Split(new[] { ',' }, StringSplitOptions.RemoveEmptyEntries);
foreach (var role in roles)
{
await UserManager.AddToRoleAsync(user, role.Trim());
}
}
return(Ok(new { Succeeded = true }));
}
return(BadRequest(new { Succeeded = false, Errors = result.Errors.Select(n => $"{n.Code}: {n.Description}") }));
}
public void MergeDictionaryWithFallback()
{
// Arrange
var expected = GetRandomString();
var src = new MergeDictionary <string, object>(
new DefaultDictionary <string, object>(() => expected)
);
Expect(src["BaseUrl"])
.To.Equal(expected);
// Act
var result = new CaseWarpingDictionaryWrapper <object>(src, true);
// Assert
Expect(result["BaseUrl"])
.To.Equal(expected);
}
public async void TestEmailGeneration()
{
var renderer = new SimpleEmailRenderer
{
BaseDirectory = ".\\EmailDirectory"
};
var replace = new MergeDictionary
{
{ "FirstName", "Nate" },
{ "LastName", "Zaugg" },
{ "Code", "12345" },
};
var result = await renderer.GenerateEmail("Welcome", "*****@*****.**", replace);
MailMessage msg = result.ToMailMessage();
// Send the message
}
private static MergeDictionary <string, object> MergeObjects(
IEnumerable <object> sources,
bool isFuzzy
)
{
var dictionaries = sources.Where(o => o != null)
.Aggregate(
new List <IDictionary <string, object> >(),
(converted, toConvert) =>
{
var asDict = MergeConversionStrategies.Aggregate(
null as IDictionary <string, object>,
(acc, cur) => acc ?? cur(toConvert, isFuzzy));
if (asDict != null)
{
converted.Add(asDict);
}
return(converted);
})
.ToArray();
var merged = new MergeDictionary <string, object>(dictionaries);
return(merged);
}
