public async Task SendEmail(string replyTo, string destination, string subject, string content)
{
if (!await _parameterManager.GetValue <bool>(ParameterTypes.EmailSenderEnabled))
{
return;
}
if (!await Connect())
{
return;
}
var message = new MimeMessage();
message.From.Add(MailboxAddress.Parse(await _parameterManager.GetValue <string>(ParameterTypes.SiteEmail)));
message.ReplyTo.Add(MailboxAddress.Parse(replyTo));
message.To.Add(MailboxAddress.Parse(destination));
message.Subject = subject;
message.Body = new BodyBuilder
{
HtmlBody = content
}.ToMessageBody();
await _smtpClient.SendAsync(message);
}
public async Task <IActionResult> ForgotPassword()
{
if (!await _parameterManager.GetValue <bool>(ParameterTypes.EmailSenderEnabled))
{
return(RedirectToAction("Index", "Content"));
}
return(_signInManager.IsSignedIn(User) ? RedirectToAction("YourProfile", "UsersManager") : View());
}
public async Task <bool> Validate(string clientSecret, string?clientIp)
{
if (!await _parameterManager.GetValue <bool>(ParameterTypes.ContactEmailRecaptchaEnabled))
{
return(false);
}
var reCaptchaRequest = new ReCaptchaRequest(await _parameterManager.GetValue <string>(ParameterTypes.ContactEmailRecaptchaServerKey), clientSecret, clientIp);
var httpResponse = await _httpClient.PostAsync(PostAddress, new FormUrlEncodedContent(Encode(reCaptchaRequest)));
var reCaptchaResponse = JsonSerializer.Deserialize <ReCaptchaResponse>(await httpResponse.Content.ReadAsStringAsync(), new JsonSerializerOptions {
PropertyNamingPolicy = JsonNamingPolicy.CamelCase
});
return(httpResponse.IsSuccessStatusCode && reCaptchaResponse.Success);
}
public async Task <IActionResult> IndexRss()
{
const string key = "index_rss";
if (_memoryCache.TryGetValue(key, out var value))
{
return(await GetRssFeed((SyndicationFeed)value));
}
var feedItems = (await GetReleases(0, Constants.ItemsPerPageReleasesRss)).Select(tuple =>
{
var title = $"{tuple.title.Name} - {Labels.Chapter} {tuple.chapter.Number}";
var description = tuple.title.Synopsis.RemoveHtmlTags() is var desc && desc.Length > 200 ? $"{desc.Substring(0, 200)}..." : desc;
var url = new Uri(Url.Action("ReadChapter", "Content", new { chapterId = tuple.chapter.Id }, Request.Scheme));
var feedItem = new SyndicationItem(title, description, url)
{
Id = tuple.chapter.Id.ToString(),
PublishDate = tuple.chapter.ReleaseDate
};
feedItem.ElementExtensions.Add("titleLink", null, new Uri(Url.Action("Titles", "Content", new { titleId = tuple.title.Id }, Request.Scheme)));
return(feedItem);
}).ToArray();
var siteName = await _parametersManager.GetValue <string>(ParameterTypes.SiteName);
var feed = new SyndicationFeed($"{siteName} RSS", $"{Labels.Home} - {siteName}", new Uri(Url.Action("Index", "Content", null, Request.Scheme)), feedItems)
{
BaseUri = new Uri(Url.Action("IndexRss", "Content", null, Request.Scheme)),
ImageUrl = new Uri($"{Request.Scheme}://{Request.Host}/assets/icon.png"),
LastUpdatedTime = DateTimeOffset.Now,
TimeToLive = TimeSpan.FromMinutes(10)
};
_memoryCache.Set(key, feed, TimeSpan.FromMinutes(10));
return(await GetRssFeed(feed));
}
public static async Task <T> GetModel <T>(this ParametersManager parametersManager) where T : new()
{
var t = new T();
foreach (var property in t.GetType().GetProperties().Where(property => Attribute.IsDefined(property, typeof(ParameterAttribute))))
{
var attribute = (ParameterAttribute)property.GetCustomAttribute(typeof(ParameterAttribute)) !;
var parameter = await parametersManager.GetValue <object?>(attribute.ParameterType);
if (parameter == null)
{
continue;
}
property.SetValue(t, Convert.ChangeType(parameter, Nullable.GetUnderlyingType(property.PropertyType) ?? property.PropertyType));
}
return(t);
}
public static async Task <T> GetValue <T>(this ParametersManager parametersManager, ParameterTypes parameterTypes) => await parametersManager.GetValue <T>((ushort)parameterTypes);
public async Task <IActionResult> Add(UserModel userModel)
{
if (ModelState.IsValid)
{
if (await _userManager.FindByEmailAsync(userModel.Email) != null)
{
return(Json(new
{
success = false,
messages = new[] { ValidationMessages.EmailAlreadyInUse }
}));
}
if (await _userManager.FindByNameAsync(userModel.Username) != null)
{
return(Json(new
{
success = false,
messages = new[] { ValidationMessages.UsernameAlreadyInUse }
}));
}
var user = Mapper.MapToEntity(userModel);
await using var transaction = await _context.Database.BeginTransactionAsync();
if (await _parameterManager.GetValue <bool>(ParameterTypes.EmailSenderEnabled))
{
var userResult = string.IsNullOrWhiteSpace(userModel.Password) ? await _userManager.CreateAsync(user) : await _userManager.CreateAsync(user, userModel.Password);
if (userResult.Succeeded)
{
if (Utilities.ToRole(userModel.Role) is var resultingRole && resultingRole != null)
{
var roleResult = await _userManager.AddToRoleAsync(user, resultingRole);
if (roleResult.Succeeded)
{
TempData["SuccessMessage"] = new[] { OtherMessages.UserCreatedEmailSent };
await transaction.CommitAsync();
await SendAccountCreationEmail(user);
return(Json(new
{
success = true,
destination = Url.Action("Index")
}));
}
}
else
{
TempData["SuccessMessage"] = new[] { OtherMessages.UserCreatedEmailSent };
await transaction.CommitAsync();
await SendAccountCreationEmail(user);
return(Json(new
{
success = true,
destination = Url.Action("Index")
}));
}
}
ModelState.AddModelError("SomethingWrong", OtherMessages.SomethingWrong);
}
else
{
user.EmailConfirmed = true;
if (!string.IsNullOrWhiteSpace(userModel.Password))
{
var userResult = await _userManager.CreateAsync(user, userModel.Password);
if (userResult.Succeeded)
{
if (Utilities.ToRole(userModel.Role) is var resultingRole && resultingRole != null)
{
var roleResult = await _userManager.AddToRoleAsync(user, resultingRole);
if (roleResult.Succeeded)
{
TempData["SuccessMessage"] = new[] { OtherMessages.UserCreatedSuccessfully };
await transaction.CommitAsync();
return(Json(new
{
success = true,
destination = Url.Action("Index")
}));
}
}
else
{
TempData["SuccessMessage"] = new[] { OtherMessages.UserCreatedSuccessfully };
await transaction.CommitAsync();
return(Json(new
{
success = true,
destination = Url.Action("Index")
}));
}
}
ModelState.AddModelError("SomethingWrong", OtherMessages.SomethingWrong);
}
public async Task <IActionResult> Blog()
{
if (!await _parametersManager.GetValue <bool>(ParameterTypes.PageBlogEnabled))
{
return(RedirectToAction("Index", "Content"));
}
ViewData["TotalPages"] = Math.Ceiling(await _postsManager.Count(_signInManager.IsSignedIn(User)) / (decimal)Constants.ItemsPerPagePosts);
return(View(await _postsManager.GetRange(0, Constants.ItemsPerPagePosts, _signInManager.IsSignedIn(User))));
}
