protected void Page_Load(object sender, EventArgs e) { GetQueryParams(); //Set display props according to lang if (PageAssemblyContext.Current.PageAssemblyInstruction.Language == "es") { lblResultsFor.Text = "resultados de:"; } else { lblResultsFor.Text = "results found for:"; } SetupCommon(); SetupCanonicalUrl(this.DictionaryRouter.GetBaseURL()); LoadData(); //set up pager stuff string pageHtml = string.Empty; if (NumResults > 0 && PageAssemblyContext.Current.DisplayVersion != DisplayVersions.Print) { Dictionary <string, string> queryParams = GetPageQueryParams(); NciUrl pagerUrl = new NciUrl(); pagerUrl.SetUrl(PageAssemblyContext.Current.requestedUrl.ToString()); DrugPager objPager = new DrugPager(pagerUrl, queryParams, CurrentPageIndex, PageSize, 2, NumResults); pageHtml = objPager.RenderPager(); } litPager.Text = pageHtml; }
// Parameter r (Redirect Flag) private void ParseRedirectFlag(NciUrl url, CTSSearchParams searchParams) { if (IsInUrl(url, "r")) { searchParams.RedirectFlag = true; } }
/// <summary> /// Use this event handler to perform operations like update /// the page meta tags , web analytics, etc /// </summary> /// <param name="e">Not used</param> protected override void OnPreRenderComplete(EventArgs e) { // Ideally we would load the trailing Stylesheests and JavaScript in OnInitComplete // or similar. The problem is, we can't guarantee that all the other code will get // it right. So we set up the trailing stuff here instead. InsertFooterStyleSheetsJavascriptsReferences(); base.OnPreRenderComplete(e); SetTitle(); InsertCanonicalURL(); InsertPageMetaData(); InsertPageLinkRels(); InsertBodyTagAttributes(); InsertHTMLTagAttributes(); //Set the form action so it does not post back to the page template path. if (this.Form != null) { NciUrl formAction = this.PageAssemblyInstruction.GetUrl("PostBackURL"); if (formAction == null || string.IsNullOrEmpty(formAction.ToString())) { //Log Error } else { this.Form.Action = formAction.ToString(); } } }
//Parameter t (Main Cancer Type) private static void SerializeCancerType(NciUrl url, CTSSearchParams searchParams) { if (searchParams.IsFieldSet(FormFields.MainType)) { url.QueryParameters.Add("t", string.Join("|", searchParams.MainType.Codes)); } }
//Parameter fin (Findings) private void ParseFindings(NciUrl url, CTSSearchParams searchParams) { if (IsInUrl(url, "fin")) { searchParams.Findings = GetTermFieldFromParam(url.QueryParameters["fin"], FormFields.Findings, searchParams); } }
// Parameter r (Redirect Flag) private static void SerializeRedirectFlag(NciUrl url, CTSSearchParams searchParams) { if (searchParams.RedirectFlag == true) { url.QueryParameters.Add("r", "1"); } }
/// <summary> /// Gets the View URL for an ID /// </summary> /// <param name="id"></param> /// <returns></returns> public string GetDetailedViewUrl(string id) { NciUrl url = new NciUrl(); url.SetUrl(string.Format(this.BaseConfig.DetailedViewPagePrettyUrlFormatter, id)); return(url.ToString()); }
// Parameter in (Investigator) private static void SerializeInvestigator(NciUrl url, CTSSearchParams searchParams) { if (searchParams.IsFieldSet(FormFields.Investigator)) { url.QueryParameters.Add("in", HttpUtility.UrlEncode(searchParams.Investigator)); } }
// Parameter lo (Lead Org) private static void SerializeLeadOrg(NciUrl url, CTSSearchParams searchParams) { if (searchParams.IsFieldSet(FormFields.LeadOrg)) { url.QueryParameters.Add("lo", HttpUtility.UrlEncode(searchParams.LeadOrg)); } }
//Parameter d (Drugs) private static void SerializeDrugs(NciUrl url, CTSSearchParams searchParms) { if (searchParms.IsFieldSet(FormFields.Drugs)) { url.QueryParameters.Add("d", SerializeMultiTermFields(searchParms.Drugs)); } }
//Parameter i (Other treatments / interventions) private static void SerializeOtherTreatments(NciUrl url, CTSSearchParams searchParms) { if (searchParms.IsFieldSet(FormFields.OtherTreatments)) { url.QueryParameters.Add("i", SerializeMultiTermFields(searchParms.OtherTreatments)); } }
// Parameter va (Search VA Only) private static void SerializeIsVAOnly(NciUrl url, CTSSearchParams searchParams) { if (searchParams.IsFieldSet(FormFields.IsVAOnly)) { url.QueryParameters.Add("va", searchParams.IsVAOnly ? "1" : "0"); } }
// Parameter loc (Location, and AtNIH if loc=nih) private static void SerializeLocation(NciUrl url, CTSSearchParams searchParams) { url.QueryParameters.Add("loc", searchParams.Location.ToString("d")); if (url.QueryParameters.ContainsKey("loc")) { switch (searchParams.Location) { //None needs not to be set //AtNIH is all that is needed for NIH case LocationType.Zip: { SerializeZipCode(url, searchParams); break; } case LocationType.CountryCityState: { SerializeCountryCityState(url, searchParams); break; } case LocationType.Hospital: { SerializeHospital(url, searchParams); break; } } } }
// Parameter hv (Healthy Volunteers) private static void SerializeHealthyVolunteers(NciUrl url, CTSSearchParams searchParams) { if (searchParams.IsFieldSet(FormFields.HealthyVolunteers)) { url.QueryParameters.Add("hv", searchParams.HealthyVolunteer.ToString("d")); //Output the decimal value of the enum as a string. } }
//Parameter q (Keyword/Phrase) private static void SerializeKeyword(NciUrl url, CTSSearchParams searchParams) { if (searchParams.IsFieldSet(FormFields.Phrase)) { url.QueryParameters.Add("q", HttpUtility.UrlEncode(searchParams.Phrase)); } }
// Parameter a (Age) private static void SerializeAge(NciUrl url, CTSSearchParams searchParams) { if (searchParams.IsFieldSet(FormFields.Age)) { url.QueryParameters.Add("a", searchParams.Age.ToString()); } }
// Parameter va (VA Only Search) private void ParseIsVAOnly(NciUrl url, CTSSearchParams searchParams) { if (IsInUrl(url, "va")) { int va = url.CTSParamAsInt("va", -1); if (va == -1) { LogParseError(FormFields.IsVAOnly, "Please enter a valid VA facility search parameter.", searchParams); } else if (va > 1) { LogParseError(FormFields.IsVAOnly, "Please enter a valid VA facility search parameter.", searchParams); } else { if (va == 0) { searchParams.IsVAOnly = false; } else { searchParams.IsVAOnly = true; } } } }
//Parameter stg (Stages) private void ParseStages(NciUrl url, CTSSearchParams searchParams) { if (IsInUrl(url, "stg")) { searchParams.Stages = GetTermFieldFromParam(url.QueryParameters["stg"], FormFields.Stages, searchParams); } }
/// <summary> /// Gets a query parameter as an int or uses a default /// </summary> /// <param name="param"></param> /// <param name="def"></param> /// <param name="isInvalid">An output variable indicating if the value was set, but was NOT a valid int</param> /// <returns></returns> public static int CTSParamAsInt(this NciUrl url, string param, int def) { string paramval = url.QueryParameters[param]; bool isInvalid; return(ParamAsInt(paramval, def, out isInvalid)); }
public string GetPagerUrl(NciUrl basePageUrl, string first, string page) { NciUrl pagerUrl = basePageUrl; if(!pagerUrl.QueryParameters.ContainsKey("first")) { pagerUrl.QueryParameters.Add("first", first); } else { pagerUrl.QueryParameters.Remove("first"); pagerUrl.QueryParameters.Add("first", first); } if (!pagerUrl.QueryParameters.ContainsKey("page")) { pagerUrl.QueryParameters.Add("page", page); } else { pagerUrl.QueryParameters.Remove("page"); pagerUrl.QueryParameters.Add("page", page); } return pagerUrl.ToString(); }
/// <summary> /// Method called to redirect old search URLs to the new search URL /// </summary> protected void RedirectToResultsList(string searchString, string contains, string first, string page) { NciUrl redirectURL = new NciUrl(); redirectURL.SetUrl(GetSearchUrl()); redirectURL.QueryParameters.Add("q", searchString); if (contains.Equals("true")) { redirectURL.QueryParameters.Add("contains", contains); } if (!string.IsNullOrEmpty(first)) { redirectURL.QueryParameters.Add("first", first); } if (!string.IsNullOrEmpty(page)) { redirectURL.QueryParameters.Add("page", page); } // Add redirect query parameter for analytics redirectURL.QueryParameters.Add("redirect", "true"); NCI.Web.CDE.Application.PermanentRedirector.DoPermanentRedirect(Response, redirectURL.ToString(), "Dictionary Friendly Name Redirect"); }
/// <summary> /// This sets up the Original Pretty URL, the current full URL and the app path /// </summary> private void SetupUrls() { //We want to use the PURL for this item. //NOTE: THIS NciUrl purl = this.PageInstruction.GetUrl(PageAssemblyInstructionUrls.PrettyUrl); if (purl == null || string.IsNullOrWhiteSpace(purl.ToString())) { throw new Exception("DynamicTrialListingPageDiseaseControl requires current PageAssemblyInstruction to provide its PrettyURL through GetURL. PrettyURL is null or empty."); } //It is expected that this is pure and only the pretty URL of this page. //This means that any elements on the same page as this app should NOT overwrite the //PrettyURL URL Filter. this.PrettyUrl = purl.ToString(); //Now, that we have the PrettyURL, let's figure out what the app paths are... NciUrl currURL = new NciUrl(); currURL.SetUrl(HttpContext.Current.Request.RawUrl); currURL.SetUrl(currURL.UriStem); //Make sure this URL starts with the pretty url if (currURL.UriStem.ToLower().IndexOf(this.PrettyUrl.ToLower()) != 0) { throw new Exception(String.Format("JSApplicationProxy: Cannot Determine App Path for Page, {0}, with PrettyURL {1}.", currURL.UriStem, PrettyUrl)); } this.CurrentUrl = currURL; }
//Parameter i (Other treatments / interventions) private void ParseOtherTreatments(NciUrl url, CTSSearchParams searchParams) { if (IsInUrl(url, "i")) { searchParams.OtherTreatments = GetTermFieldFromParam(url.QueryParameters["i"], FormFields.OtherTreatments, searchParams); } }
/// <summary> /// Parses the URL for all of the parameters for an intervention dynamic listing page /// </summary> protected override void ParseURL() { if (this.CurrAppPath == "/") { throw new HttpException(400, "Invalid Parameters"); } List <string> rawParams = new List <string>(); if (this.IsNoTrials) { NciUrl ParsedReqUrlParams = new NciUrl(true, true, true); //We need this to be lowercase and collapse duplicate params. (Or not use an NCI URL) ParsedReqUrlParams.SetUrl(this.Request.Url.Query); if (ParsedReqUrlParams.QueryParameters.Count == 0) { throw new HttpException(400, "Invalid Parameters"); } rawParams = GetRawParametersFromQueryString(ParsedReqUrlParams); SetDoNotIndex(); Response.StatusCode = 404; Response.TrySkipIisCustomErrors = true; } else { rawParams = this.CurrAppPath.Split(new char[] { '/' }, StringSplitOptions.RemoveEmptyEntries).ToList <string>(); } SetUpRawParametersForListingPage(rawParams); SetUpCanonicalUrl(); }
//Parameter d (Drugs) private void ParseDrugs(NciUrl url, CTSSearchParams searchParams) { if (IsInUrl(url, "d")) { searchParams.Drugs = GetTermFieldFromParam(url.QueryParameters["d"], FormFields.Drugs, searchParams); } }
//Parameter tt (Trial Type) private void ParseTrialTypes(NciUrl url, CTSSearchParams searchParams) { if (IsInUrl(url, "tt")) { searchParams.TrialTypes = GetLabelledFieldFromParam(url.QueryParameters["tt"], FormFields.TrialTypes, searchParams); } }
//Parameter hos (Hospital) private void ParseHospital(NciUrl url, CTSSearchParams searchParams) { HospitalLocationSearchParams locParams = new HospitalLocationSearchParams(); bool hasInvalidParam = false; if (IsInUrl(url, "hos")) { string hospital = url.CTSParamAsStr("hos"); if (!string.IsNullOrWhiteSpace(hospital)) { locParams.Hospital = hospital; } else { hasInvalidParam = true; LogParseError(FormFields.Hospital, "Please enter a valid hospital/institution parameter.", searchParams); } } else { hasInvalidParam = true; LogParseError(FormFields.Hospital, "Please enter a valid hospital/institution parameter.", searchParams); } if (!hasInvalidParam) { searchParams.LocationParams = locParams; } else { searchParams.LocationParams = new HospitalLocationSearchParams(); } }
// Parameter z (Zip Code) && zp (Zip Proximity) private void ParseZipCode(NciUrl url, CTSSearchParams searchParams) { ZipCodeLocationSearchParams locParams = new ZipCodeLocationSearchParams(); searchParams.LocationParams = locParams; if (IsInUrl(url, "z")) { string zipCode = url.CTSParamAsStr("z"); if (string.IsNullOrWhiteSpace(zipCode) || (zipCode.Length < 5)) { LogParseError(FormFields.ZipCode, "Please enter a valid zip code value.", searchParams); } string pattern = @"^[0-9]{5}$"; if (Regex.IsMatch(zipCode, pattern)) { GeoLocation geolocation = this._zipLookupSvc.GetZipCodeGeoEntry(zipCode); if (geolocation != null) { locParams.ZipCode = zipCode; locParams.GeoLocation = geolocation; if (IsInUrl(url, "zp")) { int zipRadius = url.CTSParamAsInt("zp", -1); if (zipRadius < 1 || zipRadius > 12451) { LogParseError(FormFields.ZipRadius, "Please enter a valid zip radius value.", searchParams); searchParams.LocationParams = new ZipCodeLocationSearchParams(); } else { locParams.ZipRadius = zipRadius; searchParams.LocationParams = locParams; } } else { searchParams.LocationParams = locParams; } } else { LogParseError(FormFields.ZipCode, "Please enter a valid zip code value.", searchParams); } } else { LogParseError(FormFields.ZipCode, "Please enter a valid zip code value.", searchParams); } } else { //Handle when zipcode has not been specified, but location type is zip code LogParseError(FormFields.ZipCode, "Please enter a valid zip code value.", searchParams); } }
/// <summary> /// Serialize the parameters to a URL /// </summary> /// <param name="searchParams">The search parameters to serialize</param> /// <returns>A URL with query params.</returns> public static NciUrl ConvertParamsToUrl(CTSSearchParams searchParams) { NciUrl url = new NciUrl(); _paramSerializers(url, searchParams); return(url); }
/// <summary> /// Gets an instance of a CTSSearchParams object based on params in URL. /// </summary> /// <param name="url">The URL to parse</param> /// <returns></returns> public CTSSearchParams Create(string url) { NciUrl reqUrl = new NciUrl(true, true, true); reqUrl.SetUrl(url); return(Create(reqUrl)); }