/// <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));
}
