/// <summary> /// Renders appropriate list view depending on the <see cref="ListTemplateName" /> /// </summary> /// <param name="taxonFilter">The taxonomy filter.</param> /// <param name="page">The page.</param> /// <returns> /// The <see cref="ActionResult" />. /// </returns> public virtual ActionResult ListByTaxon(ITaxon taxonFilter, int?page) { if (this.Model.HideListView(this.Request.RequestContext)) { return(this.Content(string.Empty)); } var redirectPageUrlTemplate = UrlHelpers.GetRedirectPagingUrl(taxonFilter, this.ViewBag.UrlParams, this.HttpContext.Request.QueryString.ToQueryString()); this.InitializeListViewBag(redirectPageUrlTemplate); var viewModel = this.Model.CreateListViewModel(taxonFilter, page ?? 1); if (SystemManager.CurrentHttpContext != null) { this.AddCacheDependencies(this.Model.GetKeysOfDependentObjects(viewModel)); if (viewModel.ContentType != null) { this.AddCacheVariations(viewModel.ContentType, viewModel.ProviderName); } } var fullTemplateName = this.FullListTemplateName(); return(this.View(fullTemplateName, viewModel)); }
public void GivenUrlsList_WhenAbsoluteAndValid_ShouldPassValidation(string url) { // Fixture setup // Exercise system // Verify outcome Assert.True(UrlHelpers.IsAbsoluteUrl(url)); }
private void ParsePersistedGrantKey(PersistedGrantApiDto persistedGrantApiDto) { if (!string.IsNullOrEmpty(persistedGrantApiDto.Key)) { persistedGrantApiDto.Key = UrlHelpers.QueryStringSafeHash(persistedGrantApiDto.Key); } }
public async Task <string> UploadImage(IFormFile files) { if (files.Length < 0) { return("Unsuccessful"); } try { string fileName = files.FileName; int fileID = Int32.Parse(Path.GetFileNameWithoutExtension(files.FileName)); string path = UrlHelpers.GetFileStoragePath(fileID, fileName, '\\'); path = Path.Combine(_environment.WebRootPath, _iconfiguration["ImageStore"] + "\\", path); if (!Directory.Exists(path.Replace(fileName, ""))) { Directory.CreateDirectory(path.Replace(fileName, "")); } using (var stream = new FileStream(path, FileMode.Create)) { await files.CopyToAsync(stream); } return("Success"); } catch (Exception ex) { return(ex.ToString()); } }
private string GetSetObjectPropertyResponse(string address) { var queries = UrlHelpers.CrackUrl(address); PropertyInfo info; if (typeof(TObjectProperty) == typeof(ObjectProperty)) { info = BaseSetObjectPropertyParameters <TObjectProperty> .GetPropertyInfoViaTypeLookup((Enum)(object)property); } else if (typeof(TObjectProperty) == typeof(ChannelProperty)) { info = BaseSetObjectPropertyParameters <TObjectProperty> .GetPropertyInfoViaPropertyParameter <Channel>((Enum)(object)property); } else { throw new NotImplementedException($"Handler for object property type {nameof(TObjectProperty)} is not implemented"); } var queryName = BaseSetObjectPropertyParameters <TObjectProperty> .GetParameterNameStatic((Enum)(object)property, info); if (typeof(TObjectProperty) == typeof(ChannelProperty)) { queryName += "1"; //Channel ID used for tests } var val = queries[queryName]; Assert.IsTrue(val == expectedValue, $"The value of property '{property.ToString().ToLower()}' did not match the expected value. Expected '{expectedValue}', received: '{val}'"); return("OK"); }
public void TestDomainExtraction1() { var input = "http://www.foo.com"; var domain = UrlHelpers.ExtractDomainFromUrl(input); Assert.AreEqual("www.foo.com", domain); }
public string ToString(IBuildSetting setting) { // Append all the text into one StringBuilder builder = new StringBuilder(); GetText method; foreach (Prefill name in names) { if (TextMapper.TryGetValue(name.Type, out method) == true) { builder.Append(method(name.Text, setting)); } } // Remove invalid characters string returnString = builder.ToString(); returnString = Helpers.RemoveDiacritics(returnString, builder); // Check if this needs to be a slug if (asSlug == true) { returnString = UrlHelpers.GenerateSlug(returnString); } return(returnString); }
private void ValidateHttpResponse(HttpResponseMessage response, string responseText) { if (response.StatusCode == HttpStatusCode.BadRequest) { var xDoc = XDocument.Parse(responseText); var errorMessage = xDoc.Descendants("error").First().Value; throw new PrtgRequestException($"PRTG was unable to complete the request. The server responded with the following error: {errorMessage}"); } else if (response.StatusCode == HttpStatusCode.Unauthorized) { throw new HttpRequestException("Could not authenticate to PRTG; the specified username and password were invalid."); } response.EnsureSuccessStatusCode(); if (response.RequestMessage?.RequestUri?.AbsolutePath == "/error.htm") { var errorUrl = response.RequestMessage.RequestUri.ToString(); var queries = UrlHelpers.CrackUrl(errorUrl); var errorMsg = queries["errormsg"]; throw new PrtgRequestException($"PRTG was unable to complete the request. The server responded with the following error: {errorMsg}"); } }
internal HttpRequestMessage CreateRequestMessage(TfsRestRequest request) { UriBuilder url = new UriBuilder(Configuration.Url); url.Path = UrlHelpers.JoinPath(Configuration.Url.AbsolutePath, GetRequestPath(request)); url.Query = GetRequestQuery(request); HttpRequestMessage message = new HttpRequestMessage(request.Method, url.Uri); message.Headers.UserAgent.ParseAdd( Configuration.UserAgent ?? DefaultUserAgent); foreach (KeyValuePair <string, object> header in request.Headers) { message.Headers.Add(header.Key, header.Value.ToString()); } string body = request.GetBody(); if (body != null) { message.Content = new StringContent(body, Encoding.UTF8, "application/json"); } return(message); }
public void ScriptAssetsListNotContainAssetsWithInvalidTypes() { // Arrange var jqueryJsAsset = new Asset(UrlHelpers.Combine(SCRIPTS_DIRECTORY_VIRTUAL_PATH, "jquery-1.6.2.js"), _virtualFileSystemWrapper); var testCoffeeAsset = new Asset( UrlHelpers.Combine(SCRIPTS_DIRECTORY_VIRTUAL_PATH, "TestCoffeeScript.coffee"), _virtualFileSystemWrapper); var assets = new List <IAsset> { jqueryJsAsset, testCoffeeAsset }; Exception currentException = null; var scriptAssetTypesValidator = new ScriptAssetTypesValidator(); // Act try { scriptAssetTypesValidator.Validate(assets); } catch (Exception ex) { currentException = ex; } // Assert Assert.IsNotType <InvalidAssetTypesException>(currentException); }
public async Task <IActionResult> OnGetAsync(string slug = "") { if (string.IsNullOrEmpty(slug)) { return(Page()); } var request = new GetArticleQuery(slug); var result = await _mediator.Send(request); if (result == null) { Article = new ArticleCreate { Topic = UrlHelpers.SlugToTopic(slug) }; } else { // TODO: Convert this to use a PageRoute return(Redirect($"/{slug}/Edit")); } return(Page()); }
public ActionResult TableReloadConfigUrl(TableViewModel tableData, BasicParamModel param, string tableConfigName) { var resultTableConfig = this._tableConfigService.GetTableConfigByTableName(tableConfigName); var tableConfigDetail = JsonConvert.DeserializeObject <HrmResultModel <TableConfigModel> >(resultTableConfig); if (!CheckPermission(tableConfigDetail)) { //return to Access Denied } else { var dataTableConfig = new TableViewModel(); if (tableConfigDetail.Results.FirstOrDefault() != null) { dataTableConfig = JsonConvert.DeserializeObject <TableViewModel>(tableConfigDetail.Results.FirstOrDefault().ConfigData); } tableData.Fields = dataTableConfig.Fields; TableViewModel tableDataResult = RenderTable(tableData, param, tableData.TableName, param.GroupId); tableDataResult.TableDataUrl = tableData.TableDataUrl; tableDataResult.TableReloadConfigUrl = tableData.TableReloadConfigUrl; tableDataResult.TableConfigName = tableData.TableConfigName; tableDataResult.TableName = tableData.TableName; return(View(UrlHelpers.Template("_TableContent.cshtml"), tableDataResult)); } return(View(UrlHelpers.Template("_TableContent.cshtml"), tableData)); }
protected override IWebResponse GetResponse(ref string address, string function) { if (function == nameof(XmlFunction.TableData)) { var components = UrlHelpers.CrackUrl(address); Content content = components["content"].ToEnum <Content>(); if (content == Content.Messages) { if (components["columns"] != "objid,name") { components.Remove("content"); components.Remove("columns"); components.Remove("username"); components.Remove("passhash"); if (components["start"] != null) { components.Remove("start"); } var filtered = HttpUtility.UrlDecode(components.ToString()); if (filtered != str) { Assert.Fail($"Address was '{filtered}' instead of '{str}'"); } } } } return(base.GetResponse(ref address, function)); }
private IWebResponse GetTableResponse(string address) { var components = UrlHelpers.CrackUrl(address); Content content = components["content"].DescriptionToEnum <Content>(); var count = 1; var objIds = components.GetValues("filter_objid"); if (objIds != null) { count = objIds.Length; } switch (content) { case Content.Sensors: var type = components["filter_type"] ?? "aggregation"; if (type.StartsWith("@sub(")) { type = type.Substring(5, type.Length - 6); } return(new SensorResponse(Enumerable.Range(0, count).Select(i => new SensorItem(typeRaw: type)).ToArray())); case Content.Channels: return(new ChannelResponse(new ChannelItem())); default: throw new NotImplementedException($"Unknown content '{content}' requested from {nameof(SensorFactorySourceResponse)}"); } }
private string GetTableText(string address) { var components = UrlHelpers.CrackUrl(address); var content = MultiTypeResponse.GetContent(address); switch (content) { case Content.Triggers: return(base.GetResponseText(ref address)); case Content.Channels: if (Convert.ToInt32(components["id"]) >= 4000) { return(new ChannelResponse(channels).GetResponseText(ref address)); } return(new ChannelResponse().GetResponseText(ref address)); case Content.Notifications: return(new NotificationActionResponse(new NotificationActionItem("301"), new NotificationActionItem("302"), new NotificationActionItem("303")).GetResponseText(ref address)); case Content.Schedules: return(new ScheduleResponse(new ScheduleItem()).GetResponseText(ref address)); default: throw new NotImplementedException($"Unknown content '{content}' requested from {nameof(NotificationTriggerResponse)}"); } }
/// <summary> /// Gets a bundle file by virtual path /// </summary> /// <param name="bundle">Bundle</param> /// <param name="virtualPath">Virtual path</param> /// <returns>Bundle</returns> protected virtual BundleFile GetBundleFileByVirtualPath(Bundle bundle, string virtualPath) { BundleFile file = null; string url = _virtualFileSystemWrapper.ToAbsolutePath(virtualPath); url = UrlHelpers.ProcessBackSlashes(url); url = RemoveAdditionalFileExtension(url); var bundleContext = new BundleContext(_context, BundleTable.Bundles, bundle.Path); IEnumerable <BundleFile> bundleFiles = bundle.EnumerateFiles(bundleContext); foreach (BundleFile bundleFile in bundleFiles) { string bundleFileUrl = _virtualFileSystemWrapper.ToAbsolutePath(bundleFile.VirtualFile.VirtualPath); bundleFileUrl = UrlHelpers.ProcessBackSlashes(bundleFileUrl); bundleFileUrl = RemoveAdditionalFileExtension(bundleFileUrl); if (string.Equals(bundleFileUrl, url, StringComparison.OrdinalIgnoreCase)) { file = bundleFile; break; } } return(file); }
private static int checkKnownDomains(ViewModel viewModel, string text) { var result = 0; // Yes, a regex for a URL is a beast to behold. var regex = @"(ht|f)tp(s?)\:\/\/[0-9a-zA-Z]([-.\w]*[0-9a-zA-Z])*(:(0-9)*)*(\/?)([a-zA-Z0-9\-\.\?\,\'\/\\\+&%\$#_]*)?"; var matches = Regex.Matches(text, regex); foreach (Match match in matches) { var url = match.Value.ToLower(); var domain = UrlHelpers.ExtractDomainFromUrl(url); if (viewModel.KnownDomainScores.TryGetValue(domain, out var score)) { result += score; } else { try { result += processUrl(viewModel, url); } catch { } } } return(result); }
/// <summary> /// Renders appropriate list view depending on the <see cref="ListTemplateName" /> /// </summary> /// <param name="page">The page.</param> /// <returns> /// The <see cref="ActionResult" />. /// </returns> public ActionResult Index(int?page) { var fullTemplateName = this.listTemplateNamePrefix + this.ListTemplateName; this.ViewBag.CurrentPageUrl = this.GetPageUrl(); this.ViewBag.RedirectPageUrlTemplate = this.ViewBag.CurrentPageUrl + UrlHelpers.GetRedirectPagingUrl(); if (!this.IsEmpty) { ITaxon taxonFilter = TaxonUrlEvaluator.GetTaxonFromQuery(this.HttpContext, this.Model.UrlKeyPrefix); var viewModel = this.Model.CreateListViewModel(taxonFilter: taxonFilter, page: page ?? 1); if (SystemManager.CurrentHttpContext != null) { this.AddCacheDependencies(this.Model.GetKeysOfDependentObjects(viewModel)); if (viewModel.ContentType != null) { this.AddCacheVariations(viewModel.ContentType, viewModel.ProviderName); } } return(this.View(fullTemplateName, viewModel)); } return(new EmptyResult()); }
public void TestDomainExtraction3() { var input = "https://foo.com:2020"; var domain = UrlHelpers.ExtractDomainFromUrl(input); Assert.AreEqual("foo.com", domain); }
/// <summary> /// Determines if node url is within the application or external /// </summary> /// <param name="siteMapNode"></param> /// <param name="httpContext"></param> /// <returns></returns> public static bool HasExternalUrl(this SiteMapNode siteMapNode, HttpContextBase httpContext) { string url; if (!string.IsNullOrEmpty(siteMapNode.Url)) { url = siteMapNode.Url; } else { url = siteMapNode.Url = siteMapNode.ResolveUrl(httpContext); } if (!UrlHelpers.IsAbsoluteUrl(url)) { return(false); } Uri uri = null; if (Uri.TryCreate(url, UriKind.Absolute, out uri)) { var publicFacingUrl = UrlHelpers.GetPublicFacingUrl(httpContext); var isDifferentHost = !uri.Host.Equals(publicFacingUrl.Host, StringComparison.InvariantCultureIgnoreCase); var isDifferentVirtualApplication = !uri.AbsolutePath.StartsWith(httpContext.Request.ApplicationPath, StringComparison.InvariantCultureIgnoreCase); return(isDifferentHost || isDifferentVirtualApplication); } return(false); }
/// <summary> /// Renders appropriate list view depending on the <see cref="ListTemplateName" /> /// </summary> /// <returns> /// The <see cref="ActionResult" />. /// </returns> public ActionResult Index() { var viewModel = this.Model.CreateListViewModel(null, 1); var redirectPageUrlTemplate = UrlHelpers.GetRedirectPagingUrl(); this.InitializeListViewBag(redirectPageUrlTemplate); var fullTemplateName = EventSchedulerController.ListTemplateNamePrefix + this.ListTemplateName; if (this.Model.ContentViewDisplayMode == ContentViewDisplayMode.Detail) { return(this.Details((Event)viewModel.Items.First().DataItem)); } if (SystemManager.CurrentHttpContext != null) { this.AddCacheDependencies(this.Model.GetKeysOfDependentObjects(viewModel)); if (viewModel.ContentType != null) { this.AddCacheVariations(viewModel.ContentType, viewModel.ProviderName); } } return(this.View(fullTemplateName, this.Model)); }
internal static void ValidateExternalCss(ExternalCss externalCss, RulesException errors, int index, string[] duplicateUrls) { if (string.IsNullOrWhiteSpace(externalCss.Url)) { errors.ErrorForModel(string.Format(VisualEditorStrings.ExternalCssUrlRequired, index)); externalCss.Invalid = true; } else { if (duplicateUrls.Contains(externalCss.Url)) { errors.ErrorForModel(string.Format(VisualEditorStrings.ExternalCssUrlDuplicate, index)); externalCss.Invalid = true; } if (!UrlHelpers.IsValidWebFolderUrl(externalCss.Url)) { errors.ErrorForModel(string.Format(VisualEditorStrings.ExternalCssUrlNotValid, index)); externalCss.Invalid = true; } if (externalCss.Url.Length > 255) { errors.ErrorForModel(string.Format(VisualEditorStrings.ExternalCssUrlMaxLengthExceeded, index)); externalCss.Invalid = true; } } }
public void ReplacementOfFileExtensionsInDebugModeAndUsageOfPreMinifiedFilesAllowedIsCorrect() { // Arrange IList <IAsset> assets = GetTestAssets(); var cssFileExtensionsFilter = new CssFileExtensionsFilter(_virtualFileSystemWrapper) { IsDebugMode = true, UsePreMinifiedFiles = true }; // Act IList <IAsset> processedAssets = cssFileExtensionsFilter.Transform(assets); IAsset siteAsset = processedAssets[0]; IAsset jqueryUiAccordionAsset = processedAssets[1]; IAsset testCssComponentsPathsAsset = processedAssets[2]; // Assert Assert.Equal(UrlHelpers.Combine(STYLES_DIRECTORY_VIRTUAL_PATH, "Site.css"), siteAsset.VirtualPath); Assert.Equal(UrlHelpers.Combine(STYLES_DIRECTORY_VIRTUAL_PATH, @"themes\base\jquery.ui.accordion.min.css"), jqueryUiAccordionAsset.VirtualPath); Assert.NotEqual(UrlHelpers.Combine(STYLES_DIRECTORY_VIRTUAL_PATH, @"themes\base\jquery.ui.accordion.css"), jqueryUiAccordionAsset.VirtualPath); Assert.Equal(UrlHelpers.Combine(ALTERNATIVE_STYLES_DIRECTORY_VIRTUAL_PATH, @"css\TestCssComponentsPaths.css"), testCssComponentsPathsAsset.VirtualPath); Assert.False(siteAsset.Minified); Assert.True(jqueryUiAccordionAsset.Minified); Assert.False(testCssComponentsPathsAsset.Minified); }
/// <summary> /// Get the size guide for the product /// </summary> /// <param name="currentContent"></param> /// <returns></returns> protected int GetSizeGuide(FashionProductContent currentContent) { int output = UrlHelpers.GetReferenceFromUrl(currentContent.SizeGuide); if (output > 0) { return(output); } var ancestors = ContentLoader.GetAncestors(currentContent.ContentLink); foreach (var ancestor in ancestors) { var content = ContentLoader.Get <IContent>(ancestor.ContentLink); if (content is FashionStoreSubLandingNodeContent) { output = UrlHelpers.GetReferenceFromUrl(((FashionStoreSubLandingNodeContent)content).SizeGuide); } else if (content is FashionStoreLandingNodeContent) { output = UrlHelpers.GetReferenceFromUrl(((FashionStoreLandingNodeContent)content).SizeGuide); } if (output > 0) { return(output); } } return(-1); }
private IWebResponse GetTableResponse(string address) { var components = UrlHelpers.CrackUrl(address); Content content = components["content"].ToEnum <Content>(); switch (content) { case Content.Sensors: if (components["filter_objid"] == "1") { return(new SensorResponse()); } if (countOverride != null && countOverride[Content.Sensors] == 0) { return(new SensorResponse()); } return(new SensorResponse(new SensorItem())); case Content.Channels: return(new ChannelResponse(new ChannelItem())); case Content.Triggers: return(new NotificationTriggerResponse(NotificationTriggerItem.StateTrigger())); case Content.Notifications: return(new NotificationActionResponse(new NotificationActionItem("301"))); default: throw new NotImplementedException($"Unknown content '{content}' requested from {nameof(SetNotificationTriggerResponse)}"); } }
private static string Encode(string data) { string result = !string.IsNullOrEmpty(data) ? UrlHelpers.EscapeLongDataString(data).Replace("%20", "+") : string.Empty; return(result); }
public void GivenUrlsList_WhenRelativeWithoutQueryAndValid_ShouldPassValidation(string url) { // Fixture setup // Exercise system // Verify outcome Assert.True(UrlHelpers.IsRelativeWebFolderUrl(url)); }
public ActionResult TransferParticipants(int id, string returnUrl) { returnUrl = string.IsNullOrWhiteSpace(returnUrl) ? this.Request.UrlReferrer?.AbsolutePath : UrlHelpers.ExtractFullContestsTreeUrlFromPath(returnUrl); if (!this.User.IsAdmin()) { return(this.RedirectToContestsAdminPanelWithNoPrivilegesMessage()); } var contest = this.contestsData .GetAllInactive() .Where(c => c.Id == id) .Select(TransferParticipantsViewModel.FromContest) .FirstOrDefault(); if (contest == null || contest.OfficialParticipantsCount == 0) { this.TempData[GlobalConstants.DangerMessage] = Resource.Contest_not_valid; return(this.RedirectToAction <ContestsController>(c => c.Index())); } this.ViewBag.ReturnUrl = returnUrl; return(this.View(contest)); }
private string GetSystemInfo(string address) { var components = UrlHelpers.CrackUrl(address); switch (components["category"].DescriptionToEnum <SystemInfoType>()) { case SystemInfoType.System: return(GetResponse(SystemInfoType.System)); case SystemInfoType.Hardware: return(GetResponse(SystemInfoType.Hardware)); case SystemInfoType.Software: return(GetResponse(SystemInfoType.Software)); case SystemInfoType.Processes: return(GetResponse(SystemInfoType.Processes)); case SystemInfoType.Services: return(GetResponse(SystemInfoType.Services)); case SystemInfoType.Users: return(GetResponse(SystemInfoType.Users)); default: throw new NotImplementedException(); } }
public ActionResult ReloadListChecklist(long Id) { var checklist_vm = new ChecklistViewModel(); checklist_vm.Pipelines = new PipelineGridModel() { PipelineSteps = new List <PipelineStepModel>() }; checklist_vm.Pipelines.PipelineSteps = new List <PipelineStepModel>(); checklist_vm.Checklist = new List <ChecklistModel>(); checklist_vm.ChecklistDetail = new List <ChecklistDetailModel>(); checklist_vm.ChecklistDetail = GetChecklistDetailByChecklistId(_checklistDetailService, Id); if (checklist_vm.ChecklistDetail.Count == 0) { var checklist = GetChecklistById(_checklistService, Id); if (checklist != null && checklist.Id != 0) { checklist_vm.ChecklistDetail.Add(new ChecklistDetailModel { ChecklistId = checklist.Id, ChecklistName = checklist.Name, ChecklistNote = checklist.Note, }); } } return(PartialView(UrlHelpers.View("~/Views/Shared/Checklist/_ChecklistSummary.cshtml"), checklist_vm)); }