public async Task <IActionResult> Register([FromBody] RegisterRequest request)
{
var user = new ShopUser {
UserName = request.Username, Email = request.Username
};
var result = await _userManager.CreateAsync(user, request.Password);
if (result.Succeeded)
{
_logger.LogInformation("User created a new account with password.");
await _userManager.AddToRoleAsync(user, UserRole.User.ToString());
var code = EncodeHelper.Base64Encode(await _userManager.GenerateEmailConfirmationTokenAsync(user));
var confirmationLink = UrlExtensions.EmailConfirmationLink(user.Id, code, _configuration["RedirectDomain"]);
await _emailSender.SendConfirmationEmailAsync(request.Username, confirmationLink);
_logger.LogInformation($"Confirmation email was sent to user: {user.Name}");
return(StatusCode((int)HttpStatusCode.NoContent));
}
var errorResponse = new ErrorResponse(ErrorReasons.BadRequest, result.Errors.Select(e => e.Description).FirstOrDefault());
return(StatusCode((int)HttpStatusCode.BadRequest, errorResponse));
}
public JsonResult changePasswordAjax(string currentPassword, string newPassword)
{
try
{
StaffDetails staff = Fingerprints.Common.FactoryInstance.Instance.CreateInstance <StaffDetails>();
string result = LoginData.ChangePassword(currentPassword.Trim(), newPassword.Trim(), staff.UserId.ToString());
if (result == "1")
{
string imagepath = UrlExtensions.LinkToRegistrationProcess("Content/img/logo_email.png");
Thread thread = new Thread(delegate()
{
SendMail.Sendchangepassword(staff.EmailID, newPassword.Trim(), string.Empty, Server.MapPath("~/MailTemplate"), imagepath);
});
thread.Start();
}
return(Json(result));
}
catch (Exception Ex)
{
return(Json(Ex.Message));
}
}
public ActionResult ForgetPasswordagency(string EmailId)
{
try
{
string RandomPassword = GenerateRandomPassword.GenerateRandomCode(10);
if (!LoginData.CheckEmailIdExist(EmailId, RandomPassword))
{
ViewBag.message = "If the entered email id exists then new password has been sent to the entered email id.";
return(View());
}
string imagepath = UrlExtensions.LinkToRegistrationProcess("Content/img/logo_email.png");
bool isResult = SendMail.Sendchangepassword(EmailId, RandomPassword, string.Empty, Server.MapPath("~/MailTemplate"), imagepath);
if (isResult)
{
ViewBag.message = "If the entered email id exists then new password has been sent to the entered email id.";
}
else
{
ViewBag.message = "Error occurred. Please, try again later.";
}
return(View());
}
catch (Exception Ex)
{
ViewBag.message = Ex.Message;
return(View());
}
}
public SendingMailResult SendCommentReplyNotification(CommentReplyEmailNotificationData data, CommentReplyType replyType)
{
var urlHelper = new UrlHelper(_httpContext.Request.RequestContext);
var link = string.Empty;
switch (replyType)
{
case CommentReplyType.ReplyToArticleComment:
link = urlHelper.Action(MVC.Article.ActionNames.Index, MVC.Article.Name, new
{
title = UrlExtensions.ResolveTitleForUrl(data.PostTitle),
id = data.PostId
}, _httpContext.Request.Url.Scheme);
break;
case CommentReplyType.ReplyToPageComment:
link = urlHelper.Action(MVC.Page.ActionNames.Index, MVC.Page.Name, new
{
title = UrlExtensions.ResolveTitleForUrl(data.PostTitle),
id = data.PostId
}, _httpContext.Request.Url.Scheme);
break;
case CommentReplyType.ReplyToPostComment:
link = urlHelper.Action(MVC.Post.ActionNames.Index, MVC.Post.Name, new
{
title = UrlExtensions.ResolveTitleForUrl(data.PostTitle),
id = data.PostId
}, _httpContext.Request.Url.Scheme);
break;
}
link += "#comment-" + data.CommentId;
var model = new CommentReplyNotificationModel
{
FromUserName = data.FromUserName,
ToUserName = data.ToUserName,
PostId = data.PostId,
PostTitle = data.PostTitle,
CommentText = data.CommentText,
CommentLink = link
};
var htmlText = _viewConvertor.RenderRazorViewToString(MVC.EmailTemplates.Views._CommentReplyNotification, model);
var result = Send(new MailDocument
{
Body = htmlText,
Subject =
string.Format("شما پاسخی از طرف {0} در مطلب {1} دریافت کرده اید.", data.FromUserName, data.PostTitle),
ToEmail = data.ToEmail
});
return(result);
}
private string GetHttpsSiteRoot()
{
var siteRoot = UrlExtensions.MakeSecure(_httpSiteRootThunk.Value);
if (siteRoot.StartsWith("http://", StringComparison.OrdinalIgnoreCase) || siteRoot.StartsWith("https://", StringComparison.OrdinalIgnoreCase))
{
return(siteRoot);
}
throw new InvalidOperationException("The configured HTTP site root must start with http:// or https://.");
}
public async Task Given_Instance_When_AddHitCountAsync_With_ExpanderResponse_Invoked_Then_It_Should_Return_Result()
{
var instance = new Mock <IUrl>();
instance.Setup(p => p.AddHitCountAsync <ExpanderResponse>()).ReturnsAsync(instance.Object);
var value = Task.FromResult(instance.Object);
var result = await UrlExtensions.AddHitCountAsync <ExpanderResponse>(value).ConfigureAwait(false);
result.Should().Be(instance.Object);
}
public async Task Given_Instance_When_ShortenAsync_Invoked_Then_It_Should_Return_Result()
{
var instance = new Mock <IUrl>();
instance.Setup(p => p.ShortenAsync()).ReturnsAsync(instance.Object);
var value = Task.FromResult(instance.Object);
var result = await UrlExtensions.ShortenAsync(value).ConfigureAwait(false);
result.Should().Be(instance.Object);
}
public async Task PostJob(Job jobOpportunity, IUrlHelper urlHelper)
{
if (string.IsNullOrWhiteSpace(jobOpportunity?.Title) || jobOpportunity.Id <= 0)
{
return;
}
var descriptionLength = 124;
var trimmedDescription = Regex.Replace(jobOpportunity.Description, "<.*?>", String.Empty).TrimStart();
var limitedDescription = trimmedDescription.Length > descriptionLength
? trimmedDescription.Substring(0, descriptionLength) + "..."
: trimmedDescription;
// var action = UrlExtensions.SeoUrl(jobOpportunity.Id, jobOpportunity.Title);
var action = UrlExtensions.SeoUrl("details", jobOpportunity.Id);
var payloadObject = new PayloadRequestDto()
{
text = "A new job posting has been created!",
replace_original = false,
attachments = new List <Attachment> {
new Attachment {
fallback = "Check the new posted job at " + urlHelper.AbsoluteUrl("details", jobOpportunity.Id, "jobs"),
author_name = jobOpportunity.Company.Name,
title = jobOpportunity.Title,
title_link = urlHelper.AbsoluteUrl("details", jobOpportunity.Id, "jobs"),
text = limitedDescription,
thumb_url = jobOpportunity.Company.LogoUrl,
callback_id = jobOpportunity.Id.ToString(),
color = "#3AA3E3",
attachment_type = "default",
actions = new List <AttachmentAction> {
new AttachmentAction {
name = "approve",
text = "Approve",
style = "primary",
type = "button",
value = "approve"
}, new AttachmentAction {
name = "reject",
text = "Reject",
style = "default",
type = "button",
value = "reject"
}
}
}
}
};
await PostNotification(payloadObject, _slackWebhookUrl).ConfigureAwait(false);
}
public void Test_ToQueryString()
{
var queryParams = new Dictionary <string, string>()
{
{ "param1", "value1" },
{ "param2", "value2" }
};
var queryString = UrlExtensions.ToQuerystring(queryParams);
Assert.IsNotNull(queryString);
Assert.AreEqual("?param1=value1¶m2=value2", queryString);
}
protected static Uri BuildLinkForStreamProperty(string routePrefix, string id, string version, HttpRequestMessage request)
{
var url = new UrlHelper(request);
var result = url.Route(routePrefix + RouteName.DownloadPackage, new { id, version });
var builder = new UriBuilder(UrlExtensions.MakeSecure(request.RequestUri));
builder.Path = version == null?EnsureTrailingSlash(result) : result;
builder.Query = string.Empty;
return(builder.Uri);
}
public static MvcHtmlString ImageOrDefault(this HtmlHelper helper, String id, String imageUrl, Object htmlAttributes = null, String defaultImageUrl = "~/images/missing.png", String alternateText = "", Boolean localizable = false)
{
// Culture first
var urlHelper = new UrlHelper(helper.ViewContext.RequestContext);
var newImageUrl = imageUrl;
if (localizable)
{
newImageUrl = UrlExtensions.GetLocalizedUrl(urlHelper, imageUrl);
defaultImageUrl = UrlExtensions.GetLocalizedUrl(urlHelper, defaultImageUrl);
}
// Requested image or default image if not found
return(ImageOrDefaultInternal(helper, id, newImageUrl, htmlAttributes, defaultImageUrl, alternateText));
}
public void Test_ToQueryString_With_UrlEscaping()
{
var queryParams = new Dictionary <string, string>()
{
{ "param1", "value1&" },
{ "param2", "value2&" }
};
var queryString = UrlExtensions.ToQuerystring(queryParams);
Assert.IsNotNull(queryString);
var compareUrl = $"?param1={HttpUtility.UrlEncode("value1&")}¶m2={HttpUtility.UrlEncode("value2&")}";
Assert.AreEqual(compareUrl, queryString);
}
public async Task Given_Instance_When_CreateRecordAsync_Invoked_Then_It_Should_Return_Result()
{
var instance = new Mock <IUrl>();
instance.Setup(p => p.CreateRecordAsync(It.IsAny <DateTimeOffset>(), It.IsAny <Guid>())).ReturnsAsync(instance.Object);
var value = Task.FromResult(instance.Object);
var now = DateTimeOffset.UtcNow;
var entityId = Guid.NewGuid();
var result = await UrlExtensions.CreateRecordAsync(value, now, entityId).ConfigureAwait(false);
result.Should().Be(instance.Object);
}
public async Task Given_Instance_With_Null_EntityId_When_UpdateRecordAsync_Invoked_Then_It_Should_Return_Result()
{
var instance = new Mock <IUrl>();
instance.Setup(p => p.UpdateRecordAsync <UrlResponse>(It.IsAny <DateTimeOffset>(), It.IsAny <Guid?>())).ReturnsAsync(instance.Object);
var value = Task.FromResult(instance.Object);
var now = DateTimeOffset.UtcNow;
var entityId = (Guid?)null;
var result = await UrlExtensions.UpdateRecordAsync <UrlResponse>(value, now, entityId).ConfigureAwait(false);
result.Should().Be(instance.Object);
}
private async Task <IReadOnlyDictionary <string, string> > GetVideoInfoAsync(string videoId, string sts = "")
{
var rawVideoInfo = await GetRawVideoInfoAsync(videoId, "embedded", sts).ConfigureAwait(false);
var videoInfo = UrlExtensions.SplitQuery(rawVideoInfo);
if (videoInfo.ContainsKey("errorcode"))
{
var errorCode = int.Parse(videoInfo["errorcode"], NumberStyles.AllowThousands, NumberFormatInfo.InvariantInfo);
var errorReason = videoInfo["reason"];
throw new VideoIsNotAvailable(videoId, errorCode, errorReason);
}
return(videoInfo);
}
private IEnumerable <FeedItem> MapCommentsToFeedItems(IEnumerable <RssCommentModel> list)
{
return(list.Select(item => new FeedItem
{
AuthorName = item.Author,
Content = item.Body,
LastUpdatedTime = item.UpdateDate ?? item.CreatedDate,
PublishDate = item.CreatedDate,
Title = item.Title,
Url = Url.Action(MVC.Post.ActionNames.Index, MVC.Post.Name, new
{
id = item.Id,
title = UrlExtensions.ResolveTitleForUrl(item.Title)
}, "http")
}).ToList());
}
public async Task <IActionResult> ForgotPassword([FromBody] ForgotPasswordRequest request)
{
var shopUser = await _userManager.FindByEmailAsync(request.Email);
if (shopUser != null)
{
var resetPasswordToken = EncodeHelper.Base64Encode(await _userManager.GeneratePasswordResetTokenAsync(shopUser));
var resetLink = UrlExtensions.ResetPasswordLink(shopUser.Id, resetPasswordToken,
_configuration["RedirectDomain"]);
await _emailSender.SendResetPasswordEmailAsync(request.Email, resetLink);
return(StatusCode((int)HttpStatusCode.OK, "Password recovery confirmation link was sent to your e-mail."));
}
return(StatusCode((int)HttpStatusCode.NotFound,
new ErrorResponse(ErrorReasons.NotFound, "User was not found.")));
}
public async Task PostJobResponse(Job jobOpportunity, IUrlHelper urlHelper, string responseUrl, string userId, bool approved)
{
if (string.IsNullOrWhiteSpace(jobOpportunity?.Title) || jobOpportunity.Id <= 0)
{
return;
}
var descriptionLength = 124;
var trimmedDescription = Regex.Replace(jobOpportunity.Description, "<.*?>", String.Empty).TrimStart();
var limitedDescription = trimmedDescription.Length > descriptionLength
? trimmedDescription.Substring(0, descriptionLength) + "..."
: trimmedDescription;
//var action = UrlExtensions.SeoUrl(jobOpportunity.Id, jobOpportunity.Title);
var action = UrlExtensions.SeoUrl("details", jobOpportunity.Id);
var approvedMessage = approved ? "approved" : "rejected";
var payloadObject = new PayloadRequestDto()
{
text = "A new job posting has been created!",
replace_original = true,
attachments = new List <Attachment> {
new Attachment {
fallback = "Check the new posted job at " + urlHelper.AbsoluteUrl("details", jobOpportunity.Id, "jobs"),
author_name = jobOpportunity.Company.Name,
title = jobOpportunity.Title,
title_link = urlHelper.AbsoluteUrl("details", jobOpportunity.Id, "jobs"),
text = limitedDescription,
thumb_url = jobOpportunity.Company.LogoUrl,
callback_id = jobOpportunity.Id.ToString(),
color = "#3AA3E3",
attachment_type = "default",
fields = new List <AttachmentField> {
new AttachmentField {
title = "",
value = ":ballot_box_with_check: <@" + userId + "> *" + approvedMessage + " this request*",
@short = false
}
}
}
}
};
await PostNotification(payloadObject, responseUrl).ConfigureAwait(false);
}
// This method gets called by the runtime. Use this method to configure the HTTP request pipeline.
public void Configure(IApplicationBuilder app, IHostingEnvironment env, ILoggerFactory loggerFactory)
{
loggerFactory.AddConsole(Configuration.GetSection("Logging"));
loggerFactory.AddDebug();
if (env.IsDevelopment())
{
app.UseGlimpse();
app.UseBrowserLink();
app.UseDeveloperExceptionPage();
app.UseDatabaseErrorPage();
}
else
{
app.UseExceptionHandler("/Home/Error");
// For more details on creating database during deployment see http://go.microsoft.com/fwlink/?LinkID=615859
try {
using (var serviceScope = app.ApplicationServices.GetRequiredService <IServiceScopeFactory>()
.CreateScope()) {
serviceScope.ServiceProvider.GetService <TcrIdentityDbContext>()
.Database.Migrate();
}
}
catch { }
}
app.UseIISPlatformHandler(options => options.AuthenticationDescriptions.Clear());
app.UseStaticFiles();
app.UseIdentity();
// To configure external authentication please see http://go.microsoft.com/fwlink/?LinkID=532715
app.UseMvc(routes => {
routes.MapRoute(
name: "default",
template: "{controller=Home}/{action=Index}/{id?}");
});
var httpContextAccessor = app.ApplicationServices.GetRequiredService <IHttpContextAccessor>();
UrlExtensions.Configure(httpContextAccessor);
}
/// <summary>
/// 复制请求头
/// </summary>
/// <param name="context"></param>
/// <param name="webRequest"></param>
protected virtual void CopyRequestHeaders(HttpContext context, HttpWebRequest webRequest)
{
// 扩展点：允许替换默认实现方式
// 复制请求头
foreach (string name in context.Request.Headers.AllKeys)
{
// 过滤不允许直接指定的请求头
if (s_IgnoreRequestHeaders.FirstOrDefault(x => x.Equals(name, StringComparison.OrdinalIgnoreCase)) != null)
{
continue;
}
string value = context.Request.Headers[name];
SetRequestHeader(context, webRequest, name, value);
}
// 增加一个特殊的标记，在 StreamResult.cs 中会有对应的处理逻辑
webRequest.Headers.Add("x-HttpProxyHandler", "1");
webRequest.Headers.Add("x-UserHostAddress", context.Request.UserHostAddress);
//webRequest.Headers.Remove("Cache-Control");
if (string.Equals(context.Request.Headers["Connection"], "keep-alive", StringComparison.OrdinalIgnoreCase))
{
webRequest.KeepAlive = true;
}
string referer = context.Request.Headers["Referer"];
if (string.IsNullOrEmpty(referer) == false)
{
if (referer.IndexOf("://") > 0)
{
string refererRoot = UrlExtensions.GetWebSiteRoot(referer);
string requestRoot = UrlExtensions.GetWebSiteRoot(webRequest.RequestUri.AbsoluteUri);
string referer2 = requestRoot + referer.Substring(refererRoot.Length);
SetRequestHeader(context, webRequest, "Referer", referer2);
}
}
}
public override bool TryValidateOrigin(CorsRequestContext requestContext, CorsPolicy policy, CorsResult result)
{
if (requestContext == null)
{
throw new ArgumentNullException(nameof(requestContext));
}
if (policy == null)
{
throw new ArgumentNullException(nameof(policy));
}
if (result == null)
{
throw new ArgumentNullException(nameof(result));
}
if (requestContext.Origin != null)
{
if (policy.AllowAnyOrigin)
{
if (policy.SupportsCredentials)
{
result.AllowedOrigin = requestContext.Origin;
}
else
{
result.AllowedOrigin = CorsConstants.AnyOrigin;
}
}
else if (policy.Origins.Any(x => UrlExtensions.IsSubdomainOf(requestContext.Origin, x)))
{
result.AllowedOrigin = requestContext.Origin;
}
else
{
result.ErrorMessages.Add($"Origin {requestContext.Origin} not allowed");
}
}
else
{
result.ErrorMessages.Add("No origin header present");
}
return(result.IsValid);
}
public virtual ActionResult UrlReservedWarning(string entityId, string entityName, string systemName)
{
if (string.IsNullOrEmpty(systemName))
{
return(Json(new { Result = string.Empty }, JsonRequestBehavior.AllowGet));
}
int parsedEntityId;
int.TryParse(entityId, out parsedEntityId);
var validatedSystemName = UrlExtensions.ValidateSystemName(parsedEntityId, entityName, systemName, null, false);
if (systemName.Equals(validatedSystemName, StringComparison.InvariantCultureIgnoreCase))
{
return(Json(new { Result = string.Empty }, JsonRequestBehavior.AllowGet));
}
return(Json(new { Result = string.Format("Entered page name already exists, so it will be replaced by '{0}'", validatedSystemName) }, JsonRequestBehavior.AllowGet));
}
private string GetHttpSiteRoot()
{
var siteRoot = Current.SiteRoot;
if (siteRoot == null)
{
// No SiteRoot configured in settings.
// Fallback to detected site root.
var request = GetCurrentRequest();
siteRoot = UrlExtensions.MakeSecure(request.Url.GetLeftPart(UriPartial.Authority) + '/');
}
if (!siteRoot.StartsWith("http://", StringComparison.OrdinalIgnoreCase) &&
!siteRoot.StartsWith("https://", StringComparison.OrdinalIgnoreCase))
{
throw new InvalidOperationException("The configured site root must start with either http:// or https://.");
}
return(UrlExtensions.MakeSecure(siteRoot));
}
public static async Task <SearchAdaptorResult> FindByIdAndVersionCore(
ISearchService searchService,
HttpRequestBase request,
IQueryable <Package> packages,
string id,
string version,
CuratedFeed curatedFeed,
string semVerLevel)
{
SearchFilter searchFilter;
// We can only use Lucene if:
// a) The Index contains all versions of each package
// b) The sort order is something Lucene can handle
if (TryReadSearchFilter(searchService.ContainsAllVersions, UrlExtensions.MakeSecure(request.RawUrl), searchService.ContainsAllVersions, out searchFilter) && !string.IsNullOrWhiteSpace(id))
{
var normalizedRegistrationId = id.Normalize(NormalizationForm.FormC);
var searchTerm = string.Format(CultureInfo.CurrentCulture, "Id:\"{0}\"", normalizedRegistrationId);
if (!string.IsNullOrEmpty(version))
{
searchTerm = string.Format(CultureInfo.CurrentCulture, "Id:\"{0}\" AND Version:\"{1}\"", normalizedRegistrationId, version);
searchFilter.Take = 1; // only one result is needed in this case
}
searchFilter.SearchTerm = searchTerm;
searchFilter.SemVerLevel = semVerLevel;
searchFilter.IncludePrerelease = true;
searchFilter.CuratedFeed = curatedFeed;
searchFilter.SupportedFramework = null;
searchFilter.IncludeAllVersions = true;
var results = await GetRawResultsFromSearchService(searchService, searchFilter);
return(new SearchAdaptorResult(true, results));
}
return(new SearchAdaptorResult(false, packages));
}
public virtual ActionResult AutoCompleteSearch(string term)
{
if (string.IsNullOrWhiteSpace(term))
{
return(Content(string.Empty));
}
IEnumerable <LucenePostModel> items =
LucenePostSearch.Search(term, "Title", "Body", "Labels", "Keywords", "Description").Take(10);
var data =
items.Select(x => new
{
label = x.Title,
url =
Url.Action(MVC.Post.ActionNames.Index, MVC.Post.Name,
new { id = x.PostId, title = UrlExtensions.ResolveTitleForUrl(x.Title) })
});
return(Json(data, JsonRequestBehavior.AllowGet));
}
/// <inheritdoc />
public async Task <IReadOnlyList <ClosedCaptionTrackInfo> > GetVideoClosedCaptionTrackInfosAsync(string videoId)
{
videoId.EnsureNotNull(nameof(videoId));
if (!ValidateVideoId(videoId))
{
throw new ArgumentException($"Invalid YouTube video ID [{videoId}].", nameof(videoId));
}
// Get video info
var videoInfo = await GetVideoInfoAsync(videoId).ConfigureAwait(false);
// Extract captions metadata
var playerResponseRaw = videoInfo["player_response"];
var playerResponseJson = JToken.Parse(playerResponseRaw);
var captionTracksJson = playerResponseJson.SelectToken("$..captionTracks").EmptyIfNull();
// Parse closed caption tracks
var closedCaptionTrackInfos = new List <ClosedCaptionTrackInfo>();
foreach (var captionTrackJson in captionTracksJson)
{
// Extract values
var code = captionTrackJson["languageCode"].Value <string>();
var name = captionTrackJson["name"]["simpleText"].Value <string>();
var language = new Language(code, name);
var isAuto = captionTrackJson["vssId"].Value <string>()
.StartsWith("a.", StringComparison.OrdinalIgnoreCase);
var url = captionTrackJson["baseUrl"].Value <string>();
// Enforce format
url = UrlExtensions.SetQueryParameter(url, "format", "3");
var closedCaptionTrackInfo = new ClosedCaptionTrackInfo(url, language, isAuto);
closedCaptionTrackInfos.Add(closedCaptionTrackInfo);
}
return(closedCaptionTrackInfos);
}
public static async Task <SearchAdaptorResult> SearchCore(
ISearchService searchService,
HttpRequestBase request,
IQueryable <Package> packages,
string searchTerm,
string targetFramework,
bool includePrerelease,
CuratedFeed curatedFeed,
string semVerLevel)
{
SearchFilter searchFilter;
// We can only use Lucene if:
// a) We are looking for the latest version of a package OR the Index contains all versions of each package
// b) The sort order is something Lucene can handle
if (TryReadSearchFilter(searchService.ContainsAllVersions, UrlExtensions.MakeSecure(request.RawUrl), false, out searchFilter))
{
searchFilter.SearchTerm = searchTerm;
searchFilter.IncludePrerelease = includePrerelease;
searchFilter.CuratedFeed = curatedFeed;
searchFilter.SupportedFramework = targetFramework;
searchFilter.SemVerLevel = semVerLevel;
var results = await GetResultsFromSearchService(searchService, searchFilter);
return(new SearchAdaptorResult(true, results));
}
if (!includePrerelease)
{
packages = packages.Where(p => !p.IsPrerelease);
}
packages = packages.Where(SemVerLevelKey.IsPackageCompliantWithSemVerLevelPredicate(semVerLevel));
return(new SearchAdaptorResult(false, packages.Search(searchTerm)));
}
public void SetRequestDetails(string url, string method, long?bodySize)
{
if (url == null)
{
throw new ArgumentNullException(nameof(url));
}
if (method == null)
{
throw new ArgumentNullException(nameof(method));
}
url = UrlExtensions.ToStringWithoutQuery(url);
SetAnnotation(WellKnownAnnotations.Common.Operation, operationName ?? $"{method}: {UrlNormalizer.NormalizePath(url)}");
SetAnnotation(WellKnownAnnotations.Http.Request.Url, url);
SetAnnotation(WellKnownAnnotations.Http.Request.Method, method);
if (bodySize.HasValue)
{
SetAnnotation(WellKnownAnnotations.Http.Request.Size, bodySize.Value);
}
}
public override IEnumerable <DynamicNode> GetDynamicNodeCollection()
{
var returnValue = new List <DynamicNode>();
foreach (SiteMapModel post in _postService.GetSiteMapData(20))
{
var node = new DynamicNode
{
Title = post.Title,
Controller = "Post",
Action = "Index",
Area = "",
LastModifiedDate = post.ModifiedDate ?? post.CreatedDate,
ChangeFrequency = ChangeFrequency.Daily,
UpdatePriority = UpdatePriority.Absolute_050,
};
node.RouteValues.Add("id", post.Id);
node.RouteValues.Add("title", UrlExtensions.ResolveTitleForUrl(node.Title));
returnValue.Add(node);
}
// Return
return(returnValue);
}
public override void OnActionExecuting(ActionExecutingContext filterContext)
{
if (filterContext == null)
{
throw new ArgumentNullException(nameof(filterContext));
}
if (!filterContext.HttpContext.Request.IsAuthenticated)
{
throw new InvalidOperationException("Requires account confirmation attribute is only valid on authenticated actions.");
}
var controller = ((AppController)filterContext.Controller);
var user = controller.GetCurrentUser();
if (!user.Confirmed)
{
controller.TempData["ConfirmationRequiredMessage"] = string.Format(
CultureInfo.CurrentCulture,
"Before you can {0} you must first confirm your email address.", _inOrderTo);
controller.HttpContext.SetConfirmationReturnUrl(UrlExtensions.MakeSecure(controller.Url.RequestContext.HttpContext.Request.RawUrl));
filterContext.Result = new RedirectResult(controller.Url.ConfirmationRequired(relativeUrl: false));
}
}
