private void SetSelectedStandard()
 {
     if (hiddenSelectedStandard.Value.Length > 0)
     {
         _selectedStandard = _selectedPlan.Standards.Find(t => t.ID == DataIntegrity.ConvertToInt(hiddenSelectedStandard.Value));                
     }
     else //select first standard
     {
         _selectedStandard = _selectedPlan.Standards[0];
     }
 }
        protected void Page_Load(object sender, EventArgs e)
        {
            sessionObject = (SessionObject)Session["SessionObject"];

            if (Request.QueryString["xID"] == null)
            {
                SessionObject.RedirectMessage = "No item type provided in URL.";
                Response.Redirect("~/PortalSelection.aspx", true);
            }
            else
            {
                _planID = DataIntegrity.ConvertToInt(Request.QueryString["xID"]);
                var key = "InstructionalPlan_" + _planID;
                if (!RecordExistsInCache(key)) return;
                _selectedPlan = ((Base.Classes.InstructionalPlan)Base.Classes.Cache.Get(key));

                if (Request.QueryString["assessmentID"] != null)
                {
                    _selectedAssessment = Base.Classes.Assessment.GetAssessmentByID(DataIntegrity.ConvertToInt(Request.QueryString["assessmentID"]));
                }

                if (Request.QueryString["resourceID"] != null)
                {
                    _selectedResource = Base.Classes.Resource.GetDummyResourceByID(DataIntegrity.ConvertToInt(Request.QueryString["resourceID"]));
                }

                if (Request.QueryString["lessonplanid"] != null)
                {
                    _selectedLessonPlan = Base.Classes.LessonPlan.GetPlanByID(DataIntegrity.ConvertToInt(Request.QueryString["lessonplanid"]));
                }

                if (Request.QueryString["standardid"] != null)
                {
                    _selectedStandard = Base.Classes.Standards.GetStandardByID(DataIntegrity.ConvertToInt(Request.QueryString["standardid"]));
                }

                InstructionalPlanScheduler.DataSource = _selectedPlan.CalendarEvents;
                InstructionalPlanScheduler.DataBind();

                if (Request.QueryString["view"] != null) //If a day is passed in query string, flip to day view and that date
                {
                    switch (Request.QueryString["view"].ToString())
                    {
                        case "Day":
                            InstructionalPlanScheduler.SelectedView = SchedulerViewType.DayView;
                            break;

                        case "Week":
                            InstructionalPlanScheduler.SelectedView = SchedulerViewType.WeekView;
                            break;

                        case "Month":
                        default:
                            InstructionalPlanScheduler.SelectedView = SchedulerViewType.MonthView;
                            break;
                    }
                                    
                }

                if(Request.QueryString["day"] != null) //If a day is passed in query string, flip to day view and that date
                {
                    InstructionalPlanScheduler.SelectedView = SchedulerViewType.DayView;
                    InstructionalPlanScheduler.SelectedDate = DataIntegrity.ConvertToDate(Request.QueryString["day"]);
                }                
            }
        }
		private void LoadCriteria()
		{

			_resourceTypes = KenticoHelper.GetLookupDetailsByClient(null, null);

			List<KeyValuePair> lstsel = new List<KeyValuePair>();
			lstsel.Add(new KeyValuePair { Key = "0", Value = "-- Select --" });

			var resulttype = (from s in _resourceTypes
							  where s.LookupEnum == LookupType.DocumentType
                              select new KeyValuePair { Key = s.Enum.ToString(CultureInfo.InvariantCulture), Value = s.Description })
                .ToList();

			var educationalUses = GetTagElements(Enums.LrmiTags.EducationalUse);
			var activityTypes = GetTagElements(Enums.LrmiTags.Activity);
			var learningResourceTypes = GetTagElements(Enums.LrmiTags.LearningResourceType);
			var targetTypes = GetTagElements(Enums.LrmiTags.EndUser);
			var mediaTypes = GetTagElements(Enums.LrmiTags.MediaType);
			var ageAppropriateTypes = GetTagElements(Enums.LrmiTags.AgeAppropriate);
			var usageRightTypes = GetCommonCreative();

            // create JSON objects for Media Type for LRMI and PBS Learning so that the client can switch between source types
            List<KeyValuePair> mediaTypeList = new List<KeyValuePair>();
            var mediaTypeEnum = Enum.GetValues(typeof(MediaType))
                .Cast<MediaType>()
                .Select(v => v.ToString())
                .ToList();
            foreach (string mt in mediaTypeEnum)
            {
                mediaTypeList.Add(new KeyValuePair { Value = mt, Key = Convert.ToString((int)Enum.Parse(typeof(MediaType), mt)) });
            }
		    var lrmiMediaJsonObject = Json.Encode(mediaTypes);
		    var pbsMediaJsonOjbect = Json.Encode(mediaTypeList);
            ClientScriptManager clientScript = Page.ClientScript;
            clientScript.RegisterStartupScript(GetType(), "LRMIMediaJSONObject",
                            "var lrmiMedicaJsonObject = " + lrmiMediaJsonObject.ToString(CultureInfo.InvariantCulture) + ";", true);
            clientScript.RegisterStartupScript(GetType(), "PBSMediaJSONObject",
                            "var pbsMedicaJsonObject = " + pbsMediaJsonOjbect.ToString(CultureInfo.InvariantCulture) + ";", true);


			// TFS-2887
			List<KeyValuePair> srcsel = new List<KeyValuePair>();
			List<KeyValuePair> sourcetype = new List<KeyValuePair>();
			List<KeyValuePair> gradeList = GetGradesList();

			DataSet repositoryDataSet = Repository.GetRepository();

           if ((_sessionObject.LoggedInUser.Roles.Find(r => r.RoleName.Equals(ROLE_DISTRICTADMIN, StringComparison.InvariantCultureIgnoreCase)) == null) && (_sessionObject.LoggedInUser.Roles.Find(r => r.RoleName.Equals(ROLE_SCHOOLADMIN, StringComparison.InvariantCultureIgnoreCase)) == null))
            {
                foreach (var repDataRow in repositoryDataSet.Tables[0].Select())
                {
                    if (repDataRow["repositoryName"].ToString() == TeacherMyDocsFolder.ToString())
                    {
                        repositoryDataSet.Tables[0].Rows.Remove(repDataRow);
                    }
                }
            }


			foreach (DataRow row in repositoryDataSet.Tables[0].Rows)
			{
                sourcetype.Add(new KeyValuePair
                {
                    Value = row["repositoryName"].ToString(),
                    Key = (row["repositoryName"].ToString() == TeacherMyDocsFolder.ToString() ? "TeachersMyDocsfolder" : row["repositoryName"].ToString())
                });
			}

			// Begin source changes TFS-2887

			//Source Criteria
			srcsel.Add(new KeyValuePair { Key = "0", Value = "-- Select --" });            
			srcsel.AddRange(sourcetype);

			Criterion sourceCriteria = new Criterion
			{
				UIType = UIType.DropDownList,
				Key = "Source",
				Header = "Source:",
				DataTextField = "Value",
				DataValueField = "Key",
                DataSource = srcsel,
                IsRequired = true
			};

			SearchControl.Criteria.Criterias.Add(sourceCriteria);

			// End source changes TFS-2887


            //Begin Teacher Control
            #region School Name as loggedin user

            DataTable dtSchoolList = new DataTable();
            dtSchoolList.Columns.Add("Key", typeof(string));
            dtSchoolList.Columns.Add("Value", typeof(int));

            var schoolList = SchoolMasterList.GetSchoolsForUser(SessionObject.LoggedInUser);

            if (SessionObject.LoggedInUser.Roles.Find(r => r.RoleName.Equals(ROLE_SCHOOLADMIN, StringComparison.InvariantCultureIgnoreCase)) != null && SessionObject.LoggedInUser.Schools.Count > 1)
            {
                DataRow dr = dtSchoolList.NewRow();

                var key = "School_" + SessionObject.LoggedInUser.School;

                if (!RecordExistsInCache(key)) return;
                var schoolText = ((Base.Classes.School)Base.Classes.Cache.Get(key)).Name;

                dr["Key"] = schoolText;
                dr["Value"] = SessionObject.LoggedInUser.School;
                dtSchoolList.Rows.Add(dr);
            }
            else if (schoolList != null)
            {
                foreach (Base.Classes.School school in schoolList)
                {
                    DataRow dr = dtSchoolList.NewRow();
                    dr["Key"] = school.Name;
                    dr["Value"] = school.ID;
                    dtSchoolList.Rows.Add(dr);
                }
            }

            List<KeyValuePair<String, int>> schoolSetList = new List<KeyValuePair<string, int>>();
            foreach (DataRow dr in dtSchoolList.Rows)
            {
                schoolSetList.Add(new KeyValuePair<string, int>(dr["Key"].ToString(), Convert.ToInt16(dr["Value"])));
            }
            if (schoolSetList.Count > 1)
            {
                schoolSetList.Insert(0, new KeyValuePair<string, int>("Select School", 0));
            }
           

            Criterion teacherCriteria = new Criterion
            {
                UIType = UIType.SchoolGradeName,
                Key = "SchoolGradeName",
                Header = "Teacher:",
                SchoolDataSource = schoolSetList,
                GradesDataSource = new List<KeyValuePair> { new KeyValuePair("0", "Select Grade") },
                TeacherNameDataSource = new List<KeyValuePair> { new KeyValuePair("0", "Select Name") },
                IsRequired = true                
            };

            SearchControl.Criteria.Criterias.Add(teacherCriteria);
            #endregion
            //End Teacher Control


			var typeValue = (from s in resulttype where s.Key == _typeKey select s.Value);
			//Type Criteria

			lstsel.AddRange(resulttype);

			Criterion typeCriteria = new Criterion
			{
				UIType = UIType.DropDownList,
				Key = "Type",
				Header = "Type:",
				DataTextField = "Value",
				DataValueField = "Key",
				DataSource = lstsel
			};
			var typeValueenumerable = typeValue as IList<string> ?? typeValue.ToList();
			if (typeValueenumerable.Any())
			{
				typeCriteria.DefaultValue = new KeyValuePair(_typeKey, typeValueenumerable.ElementAt(0));
			}

			//SubType Criteria

			var resultsubtype = (from s in _resourceTypes
								 where Convert.ToInt32(s.LookupEnum) >= 43 && Convert.ToInt32(s.LookupEnum) <= 51
                                 select new KeyValuePair { Key = s.Enum.ToString(CultureInfo.InvariantCulture), Value = s.Description })
                .ToList();
			resultsubtype.Insert(0, new KeyValuePair("0", "-- Select --"));

			Criterion subtypeCriteria = new Criterion
			{
				UIType = UIType.DropDownList,
				Key = "SubType",
				Header = "SubType:",
				DataTextField = "Value",
				DataValueField = "Key",
				HandlerName = "populatesubtype"
			};
			subtypeCriteria.Dependencies.Add(Criterion.CreateDependency("Type"));
			subtypeCriteria.DataSource = resultsubtype;


			//Resource Name

			Criterion textCriteria = new Criterion
			{
				UIType = UIType.TextBoxEdit,
				Key = "Text",
				Header = "Text Search:",
				DataTextField = "Value",
				DataValueField = "Key",
				EditMask = EditMaskType.NoMask
				//DataSource = GetTextSearchOptions()
			};

			Criterion keywordsCriteria = new Criterion
			{
				UIType = UIType.TextBoxEdit,
				Key = "Keywords",
				Header = "Keywords:",
				DataTextField = "Value",
				DataValueField = "Key",
				EditMask = EditMaskType.NoMask
			};

			SearchControl.Criteria.Criterias.Add(typeCriteria);
			SearchControl.Criteria.Criterias.Add(subtypeCriteria);
			SearchControl.Criteria.Criterias.Add(textCriteria);
			SearchControl.Criteria.Criterias.Add(keywordsCriteria);

			//Criterion uiTableCriteria = new Criterion {UIType = Base.Enums.UIType.UITable};
			//SearchControl.Criteria.Criterias.Add(uiTableCriteria);

			List<KeyValuePair> standardSetList = GetStandardSetList();
			standardSetList.Insert(0, new KeyValuePair("0", "Select Set"));

			SessionObject sessionObject = (SessionObject)Session["SessionObject"];
			var courses = CourseMasterList.GetStandardCoursesForUser(sessionObject.LoggedInUser);
			courses.AddRange(CourseMasterList.GetClassCoursesForUser(sessionObject.LoggedInUser));
			courses.AddRange(CourseMasterList.GetCurrCoursesForUser(sessionObject.LoggedInUser));
			var allCourses = courses.AsEnumerable<Base.Classes.Course>().ToList();

			var allSubjects = allCourses.GroupBy(g => new { g.Subject.DisplayText });
			var subjects = (from s in allSubjects
							select new KeyValuePair
							{
								Key = s.Key.DisplayText,
								Value = s.Key.DisplayText,
							}).OrderBy(s => s.Value).ToList();
			subjects.Insert(0, new KeyValuePair("0", "Select Subject"));

			var allCurriculums = allCourses.GroupBy(g => new { g.CourseName });
			var listCourses = (from s in allCurriculums
							   select new KeyValuePair
							   {
								   Key = s.Key.CourseName,
								   Value = s.Key.CourseName,
							   }).OrderBy(s => s.Value).ToList();
			listCourses.Insert(0, new KeyValuePair("0", "Select Curriculum"));

			SearchControl.ToolTipDelayHide = 20; //Seconds
			// Curricula Criteria Control
			Criterion curriculaCriteria = new Criterion
			{
				UIType = UIType.GradeSubjectCurricula,
				Key = "Curriculum",
				Header = "Curriculum:",
				GradesDataSource = gradeList,
				SubjectsDataSource = subjects,
				CurriculaDataSource = listCourses
			};

			SearchControl.Criteria.Criterias.Add(curriculaCriteria);

			//Standard Criteria Controls
			Criterion standardCriteria = new Criterion
			{
				UIType = UIType.GradeSubjectStandards,
				Key = "Standards",
				Header = "Standards:",
				StandardSetDataSource = standardSetList,
				GradesDataSource = new List<KeyValuePair> { new KeyValuePair("0", "Select Grade") },
				SubjectsDataSource = new List<KeyValuePair> { new KeyValuePair("0", "Select Subject") },
				CourseDataSource = new List<KeyValuePair> { new KeyValuePair("0", "Select Course") },
				StandardsDataSource = new List<KeyValuePair> { new KeyValuePair("0", "Select Standards") }
			};

			SearchControl.Criteria.Criterias.Add(standardCriteria);

            /* Criteria Pre-Selection For Suggested Resources */
            if (_from.Equals("suggestedresources", StringComparison.InvariantCultureIgnoreCase))
            {
                Criterion sourceCriteriaSR = this.SearchControl.Criteria.Criterias.Find(c => c.Key.Equals("Source"));
                Criterion standardsCriteriaSR = this.SearchControl.Criteria.Criterias.Find(c => c.Key.Equals("Standards"));

                if (sourceCriteriaSR != null)
                {
                    sourceCriteriaSR.DefaultValue = new KeyValuePair("MyDocs", "MyDocs");
                }
                if (standardsCriteriaSR != null)
                {
                    _standard = Base.Classes.Standards.GetStandardByID(int.Parse(_selectedStandardId));
                    string props = (new JavaScriptSerializer()).Serialize(new { StandardId = _standard.ID, StandardSet = _standard.Standard_Set, StandardName = _standard.StandardName, Grade = _standard.Grade, Subject = _standard.Subject, CourseName = _standard.Course });
                    standardsCriteriaSR.DefaultValue = new KeyValuePair(_standard.ID.ToString(), props);
                }
            }

            #region Criterion: Expiration Date
            Criterion expirationDate = new Criterion
            {
                Header = "Expiration Date",
                Key = "ExpirationDate",
                Locked = false,
                UIType = UIType.DateRange
            };

           
            #endregion
            SearchControl.Criteria.Criterias.Add(expirationDate);

            List<KeyValuePair> ratingList = new List<KeyValuePair>();
		    List<RatingRange> ratingRange = _reviewFacade.GetRatingFilterForItemSearch().ToList();
            foreach (RatingRange r in ratingRange)
            {
                ratingList.Add(new KeyValuePair { Key = r.Id.ToString(), Value = r.DisplayValue });
            }
           
            // Rating
            Criterion ratingCriteria = new Criterion
            {
                UIType = UIType.CheckBoxList,
                Key = "AverageRating",
                Header = "Average Rating:",
                DataTextField = "Value",
                DataValueField = "Key",
                DataSource = ratingList
            };
            SearchControl.Criteria.Criterias.Add(ratingCriteria);

			// Assessed
			Criterion assessedCriteria = new Criterion
			{
				UIType = UIType.GradeSubjectStandards,
				Key = "Assessed",
				Header = "Assessed:",
				StandardSetDataSource = standardSetList,
				GradesDataSource = new List<KeyValuePair> { new KeyValuePair("0", "Select Grade") },
				SubjectsDataSource = new List<KeyValuePair> { new KeyValuePair("0", "Select Subject") },
				CourseDataSource = new List<KeyValuePair> { new KeyValuePair("0", "Select Course") },
				StandardsDataSource = new List<KeyValuePair> { new KeyValuePair("0", "Select Standards") }
			};
			// Teaches
			Criterion teachesCriteria = new Criterion
			{
				UIType = UIType.GradeSubjectStandards,
				Key = "Teaches",
				Header = "Teaches:",
				StandardSetDataSource = standardSetList,
				GradesDataSource = new List<KeyValuePair> { new KeyValuePair("0", "Select Grade") },
				SubjectsDataSource = new List<KeyValuePair> { new KeyValuePair("0", "Select Subject") },
				CourseDataSource = new List<KeyValuePair> { new KeyValuePair("0", "Select Course") },
				StandardsDataSource = new List<KeyValuePair> { new KeyValuePair("0", "Select Standards") }
			};
			// Requires
			Criterion requiresCriteria = new Criterion
			{
				UIType = UIType.GradeSubjectStandards,
				Key = "Requires",
				Header = "Requires:",
				StandardSetDataSource = standardSetList,
				GradesDataSource = new List<KeyValuePair> { new KeyValuePair("0", "Select Grade") },
				SubjectsDataSource = new List<KeyValuePair> { new KeyValuePair("0", "Select Subject") },
				CourseDataSource = new List<KeyValuePair> { new KeyValuePair("0", "Select Course") },
				StandardsDataSource = new List<KeyValuePair> { new KeyValuePair("0", "Select Standards") }
			};
			// Text Complexity
			Criterion textComplexityCriteria = new Criterion
			{
				UIType = UIType.TextBoxEdit,
				Key = "TextComplexity",
				Header = "Text&nbsp;Complexity:",
				DataTextField = "Value",
				DataValueField = "Key",
				EditMask = EditMaskType.NoMask
			};
			// Reading Level
			Criterion readingLevelCriteria = new Criterion
			{
				UIType = UIType.TextBoxEdit,
				Key = "ReadingLevel",
				Header = "Reading&nbsp;Level:",
				DataTextField = "Value",
				DataValueField = "Key",
				EditMask = EditMaskType.NoMask
			};
			// Educational Subject

			List<KeyValuePair> edSubjectList = new List<KeyValuePair>();

			CourseList currCourseList = CourseMasterList.GetCurrCoursesForUser(_sessionObject.LoggedInUser);
			IEnumerable<Subject> subjectList = currCourseList.GetSubjectList().OrderBy(sub => sub.DisplayText);
			foreach (Subject sList in subjectList)
			{
				edSubjectList.Add(new KeyValuePair { Key = sList.DisplayText, Value = sList.DisplayText });
			}

			Criterion educationalSubjectCriteria = new Criterion
			{
				UIType = UIType.CheckBoxList,
				Key = "EducationalSubject",
				Header = "Educational&nbsp;Subject:",
				DataTextField = "Value",
				DataValueField = "Key",
				DataSource = edSubjectList
			};
			// Grades
			Criterion gradeCriteria = new Criterion
			{
				UIType = UIType.CheckBoxList,
				Key = "Grades",
				Header = "Grades:",
				DataTextField = "Value",
				DataValueField = "Key",
				DataSource = gradeList
			};
			// Instruction Type
			Criterion EducationalUse = new Criterion
			{
				UIType = UIType.CheckBoxList,
				Key = "EducationalUse",
				Header = "Eductional&nbsp;Use:",
				DataTextField = "Value",
				DataValueField = "Key",
				DataSource = educationalUses
			};
			// Activity Type
			Criterion interactivityTypeCriteria = new Criterion
			{
				UIType = UIType.CheckBoxList,
				Key = "InteractivityType",
				Header = "Interactivity&nbsp;Type:",
				DataTextField = "Value",
				DataValueField = "Key",
				DataSource = activityTypes
			};
			// Learning Resource Type
			Criterion learningResourceCriteria = new Criterion
			{
				UIType = UIType.CheckBoxList,
				Key = "LearningResource",
				Header = "Learning&nbsp;Resource:",
				DataTextField = "Value",
				DataValueField = "Key",
				DataSource = learningResourceTypes
			};
			// Target Audience
			Criterion endUser = new Criterion
			{
				UIType = UIType.CheckBoxList,
				Key = "EndUser",
				Header = "End&nbsp;User:"******"Value",
				DataValueField = "Key",
				DataSource = targetTypes
			};
			// Duration
			Criterion durationCriteria = new Criterion
			{
				UIType = UIType.Duration,
				Key = "Duration",
				Header = "Time&nbsp;Required:",
				DataTextField = "Value",
				DataValueField = "Key",
				EditMask = EditMaskType.NumericMask
			};
			// Age Appropriate
			ageAppropriateTypes.Add(new KeyValuePair { Key = "0", Value = "-- Select --" });
			ageAppropriateTypes = ageAppropriateTypes.OrderBy(o => o.Key).ToList();
			Criterion ageAppropriateCriteria = new Criterion
			{
				UIType = UIType.DropDownList,
				Key = "AgeAppropriate",
				Header = "Age&nbsp;Appropriate:",
				DataTextField = "Value",
				DataValueField = "Key",
				DataSource = ageAppropriateTypes
			};
			// Media Type
			//List<KeyValuePair> mediaTypeList = new List<KeyValuePair>();
			//mediaTypeList.Add(new KeyValuePair { Key = "0", Value = "-- Select --" });
			//var mediaType = Enum.GetValues(typeof(MediaType))
			//    .Cast<MediaType>()
			//    .Select(v => v.ToString())
			//    .ToList();
			//foreach (string mt in mediaType)
			//{
			//    mediaTypeList.Add(new KeyValuePair { Key = mt, Value = mt });
			//}

			Criterion mediaCriteria = new Criterion
			{
				UIType = UIType.CheckBoxList,
				Key = "MediaType",
				Header = "Media&nbsp;Type:",
				DataTextField = "Value",
				DataValueField = "Key",
				DataSource = mediaTypes
			};

			// Language Type
			List<KeyValuePair> languageTypeList = new List<KeyValuePair>();
			languageTypeList.Add(new KeyValuePair { Key = "0", Value = "-- Select --" });
			var languageType = Enum.GetValues(typeof(LanguageType))
				.Cast<LanguageType>()
				.Select(v => v.ToString())
				.ToList();
			foreach (string langt in languageType)
			{
				languageTypeList.Add(new KeyValuePair { Key = langt, Value = langt });
			}

			Criterion languageCriteria = new Criterion
			{
				UIType = UIType.DropDownList,
				Key = "Language",
				Header = "Language:",
				DataTextField = "Value",
				DataValueField = "Key",
				DataSource = languageTypeList
			};

			// Creator
			Criterion creatorCriterion = new Criterion
			{
				UIType = UIType.TextBoxEdit,
				Key = "Creator",
				Header = "Creator:",
				DataTextField = "Value",
				DataValueField = "Key",
				EditMask = EditMaskType.NoMask
			};

			// Publisher
			Criterion publisherCriteria = new Criterion
			{
				UIType = UIType.TextBoxEdit,
				Key = "Publisher",
				Header = "Publisher:",
				DataTextField = "Value",
				DataValueField = "Key",
				EditMask = EditMaskType.NoMask
			};

			// Usage Rights

			usageRightTypes.Add(new KeyValuePair { Key = "0", Value = "-- Select --" });
			usageRightTypes = usageRightTypes.OrderBy(o => o.Key).ToList();
			Criterion usageRightsCriteria = new Criterion
			{
				UIType = UIType.DropDownList,
				Key = "UsageRights",
				Header = "Usage&nbsp;Rights:",
				DataTextField = "Value",
				DataValueField = "Key",
				DataSource = usageRightTypes
			};

			SearchLMRIControl.Criteria.Criterias.Add(gradeCriteria);
			SearchLMRIControl.Criteria.Criterias.Add(educationalSubjectCriteria);
			SearchLMRIControl.Criteria.Criterias.Add(learningResourceCriteria);
			SearchLMRIControl.Criteria.Criterias.Add(EducationalUse);
			SearchLMRIControl.Criteria.Criterias.Add(endUser);
			SearchLMRIControl.Criteria.Criterias.Add(creatorCriterion);
			SearchLMRIControl.Criteria.Criterias.Add(publisherCriteria);
			SearchLMRIControl.Criteria.Criterias.Add(usageRightsCriteria);
			SearchLMRIControl.Criteria.Criterias.Add(mediaCriteria);
			SearchLMRIControl.Criteria.Criterias.Add(languageCriteria);
			SearchLMRIControl.Criteria.Criterias.Add(ageAppropriateCriteria);
			SearchLMRIControl.Criteria.Criterias.Add(durationCriteria);

			SearchLMRIControl.Criteria.Criterias.Add(assessedCriteria);
			SearchLMRIControl.Criteria.Criterias.Add(teachesCriteria);
			SearchLMRIControl.Criteria.Criterias.Add(requiresCriteria);
			SearchLMRIControl.Criteria.Criterias.Add(textComplexityCriteria);
			SearchLMRIControl.Criteria.Criterias.Add(readingLevelCriteria);
			SearchLMRIControl.Criteria.Criterias.Add(interactivityTypeCriteria);
		}
        private void LoadStandard()
        {
            if (Request.QueryString["xID"] == null)
            {
                SessionObject.RedirectMessage = "No entity ID provided in URL.";
                Response.Redirect("~/PortalSelection.aspx", true);

            }
            else
            {
                _standardId = GetDecryptedEntityId(X_ID);
                var key = "Standard_" + _standardId;

                if (!RecordExistsInCache(key))
                {
                    _selectedStandard = Base.Classes.Standards.GetStandardByID(_standardId);
                    if (_selectedStandard != null)
                        Base.Classes.Cache.Insert(key, _selectedStandard);
                    else
                    {
                        SessionObject.RedirectMessage = "Could not find the Standard.";
                        Response.Redirect("~/PortalSelection.aspx", true);
                    }
                }
                else _selectedStandard = (Base.Classes.Standards)Cache[key];

                // Set the page title text.
                if (_selectedStandard != null)
                {
                    _standardTitle = _selectedStandard.StandardName ?? string.Empty;
                }
            }
        }