Пример #1
0
 public virtual void Initialize(AspViewEngine newViewEngine, TextWriter output, IEngineContext newContext,
                                IController newController, IControllerContext newControllerContext, IDictionary parentProperties)
 {
     if (initialized)
     {
         throw new ApplicationException("Sorry, but a view instance cannot be initialized twice");
     }
     initialized       = true;
     viewEngine        = newViewEngine;
     OutputWriter      = output;
     Context           = newContext;
     Controller        = newController;
     controllerContext = newControllerContext;
     if (parentProperties == null)
     {
         Properties = ExtractProperties();
     }
     else
     {
         Properties = new ViewPropertiesDictionary(parentProperties);
     }
     if (newContext != null && newContext.Services != null && newContext.Services.DictionaryAdapterFactory != null)
     {
         dictionaryAdapterFactory = newContext.Services.DictionaryAdapterFactory;
     }
     else
     {
         dictionaryAdapterFactory = new DictionaryAdapterFactory();
     }
     outputWriters = new Stack <TextWriter>();
     viewFilters   = new Stack <IViewFilter>();
 }
		public void TwoScopes_WhenLocalScopeHides_ParentScopeDoesNotChange()
		{
			var parent = new ParametersDictionary();
			parent[keys[0]] = values[0];

			var dict = new ViewPropertiesDictionary(parent);
			dict[keys[0]] = values[1];

			Assert.That(parent[keys[0]], Is.EqualTo(values[0]));
		}
		public void SingleScope_Sanity()
		{
			var dict = new ViewPropertiesDictionary();

			dict[keys[0]] = values[0];
			dict[keys[1]] = values[1];

			Assert.That(dict[keys[0]], Is.EqualTo(values[0]));
			Assert.That(dict[keys[1]], Is.EqualTo(values[1]));
		}
Пример #4
0
        public void SingleScope_Sanity()
        {
            var dict = new ViewPropertiesDictionary();

            dict[keys[0]] = values[0];
            dict[keys[1]] = values[1];

            Assert.That(dict[keys[0]], Is.EqualTo(values[0]));
            Assert.That(dict[keys[1]], Is.EqualTo(values[1]));
        }
		public void TwoScopes_BothScopesAreVisible()
		{
			var parent = new ParametersDictionary();
			parent[keys[0]] = values[0];

			var dict = new ViewPropertiesDictionary(parent);
			dict[keys[1]] = values[1];

			Assert.That(dict[keys[0]], Is.EqualTo(values[0]));
			Assert.That(dict[keys[1]], Is.EqualTo(values[1]));
		}
Пример #6
0
        public void TwoScopes_WhenLocalScopeHides_ParentScopeDoesNotChange()
        {
            var parent = new ParametersDictionary();

            parent[keys[0]] = values[0];

            var dict = new ViewPropertiesDictionary(parent);

            dict[keys[0]] = values[1];

            Assert.That(parent[keys[0]], Is.EqualTo(values[0]));
        }
Пример #7
0
        private IDictionary ExtractProperties()
        {
            var properties = new ViewPropertiesDictionary();

            if (Context != null)
            {
                properties.Add("context", Context);
                properties.Add("request", Context.Request);
                properties.Add("response", Context.Response);
                properties.Add("session", Context.Session);
            }
            properties.Add("controller", Controller);

            Merge(controllerContext.Resources, properties);
            Merge(controllerContext.Helpers, properties);

            if (Context == null)
            {
                return(properties);
            }

            if (viewEngine.Options.Include(ViewPropertiesInclusionOptions.RequestParams))
            {
                var paramsDictionary = GetRequestParamsDictionary(Context.Request.Params);
                Merge(paramsDictionary, properties);
            }
            else
            {
                if (viewEngine.Options.Include(ViewPropertiesInclusionOptions.QueryString))
                {
                    Merge(Context.Request.QueryString, properties);
                }
                if (viewEngine.Options.Include(ViewPropertiesInclusionOptions.Form))
                {
                    Merge(Context.Request.Form, properties);
                }
            }
            Merge(Context.Flash, properties);
            Merge(controllerContext.PropertyBag, properties);

            if (properties.Contains("siteRoot") == false)
            {
                properties["siteRoot"] = Context.ApplicationPath ?? string.Empty;
            }
            if (properties.Contains("fullSiteRoot") == false)
            {
                properties["fullSiteRoot"] = Context.Request.Uri != null
                                                                                        ? Context.Request.Uri.GetLeftPart(UriPartial.Authority) + Context.ApplicationPath
                                                                                        : string.Empty;
            }
            return(properties);
        }
Пример #8
0
        public void TwoScopes_BothScopesAreVisible()
        {
            var parent = new ParametersDictionary();

            parent[keys[0]] = values[0];

            var dict = new ViewPropertiesDictionary(parent);

            dict[keys[1]] = values[1];

            Assert.That(dict[keys[0]], Is.EqualTo(values[0]));
            Assert.That(dict[keys[1]], Is.EqualTo(values[1]));
        }
		public void MultipleScopes_WhenLocalScopeHides_ParentScopeDoesNotChange()
		{
			var level0 = new ParametersDictionary();

			level0[keys[0]] = "key0_level0";
			level0[keys[1]] = "key1_level0";
			level0[keys[2]] = "key2_level0";
			level0[keys[3]] = "key3_level0";

			var level1 = new ViewPropertiesDictionary(level0);
			level1[keys[0]] = "key0_level1";
			level1[keys[4]] = "key4_level1";
			level1[keys[5]] = "key5_level1";
			level1[keys[6]] = "key6_level1";

            var level2 = new ViewPropertiesDictionary(level1);
			level2[keys[0]] = "key0_level2";
			level2[keys[1]] = "key1_level2";
			level2[keys[4]] = "key4_level2";
			level2[keys[7]] = "key7_level2";
			level2[keys[8]] = "key8_level2";

			var level3 = new ViewPropertiesDictionary(level2);
			level3[keys[0]] = "key0_level3";
			level3[keys[1]] = "key1_level3";
			level3[keys[2]] = "key2_level3";
			level3[keys[4]] = "key4_level3";
			level3[keys[7]] = "key7_level3";
			level3[keys[9]] = "key9_level3";


			// Level 0 
			Assert.That(level0[keys[0]], Is.EqualTo("key0_level0"));
			Assert.That(level0[keys[1]], Is.EqualTo("key1_level0"));
			Assert.That(level0[keys[2]], Is.EqualTo("key2_level0"));
			Assert.That(level0[keys[3]], Is.EqualTo("key3_level0"));
			foreach (var i in Enumerable.Range(4, Range-4))
			{
				Assert.That(level0.Contains(keys[i]), Is.Not.True);
			}

			// Level 1 
			Assert.That(level1[keys[0]], Is.EqualTo("key0_level1"));
			Assert.That(level1[keys[1]], Is.EqualTo("key1_level0"));
			Assert.That(level1[keys[2]], Is.EqualTo("key2_level0"));
			Assert.That(level1[keys[3]], Is.EqualTo("key3_level0"));
			Assert.That(level1[keys[4]], Is.EqualTo("key4_level1"));
			Assert.That(level1[keys[5]], Is.EqualTo("key5_level1"));
			Assert.That(level1[keys[6]], Is.EqualTo("key6_level1"));
			foreach (var i in Enumerable.Range(7, Range - 7))
			{
				Assert.That(level1.Contains(keys[i]), Is.Not.True);
			}

			// Level 2
			Assert.That(level2[keys[0]], Is.EqualTo("key0_level2"));
			Assert.That(level2[keys[1]], Is.EqualTo("key1_level2"));
			Assert.That(level2[keys[2]], Is.EqualTo("key2_level0"));
			Assert.That(level2[keys[3]], Is.EqualTo("key3_level0"));
			Assert.That(level2[keys[4]], Is.EqualTo("key4_level2"));
			Assert.That(level2[keys[5]], Is.EqualTo("key5_level1"));
			Assert.That(level2[keys[6]], Is.EqualTo("key6_level1"));
			Assert.That(level2[keys[7]], Is.EqualTo("key7_level2"));
			Assert.That(level2[keys[8]], Is.EqualTo("key8_level2"));
			foreach (var i in Enumerable.Range(9, Range - 9))
			{
				Assert.That(level2.Contains(keys[i]), Is.Not.True);
			}

			// Level 3
			Assert.That(level3[keys[0]], Is.EqualTo("key0_level3"));
			Assert.That(level3[keys[1]], Is.EqualTo("key1_level3"));
			Assert.That(level3[keys[2]], Is.EqualTo("key2_level3"));
			Assert.That(level3[keys[3]], Is.EqualTo("key3_level0"));
			Assert.That(level3[keys[4]], Is.EqualTo("key4_level3"));
			Assert.That(level3[keys[5]], Is.EqualTo("key5_level1"));
			Assert.That(level3[keys[6]], Is.EqualTo("key6_level1"));
			Assert.That(level3[keys[7]], Is.EqualTo("key7_level3"));
			Assert.That(level3[keys[8]], Is.EqualTo("key8_level2"));
			Assert.That(level3[keys[9]], Is.EqualTo("key9_level3"));
			foreach (var i in Enumerable.Range(10, Range - 10))
			{
				Assert.That(level3.Contains(keys[i]), Is.Not.True);
			}
		}
Пример #10
0
        public void MultipleScopes_WhenLocalScopeHides_ParentScopeDoesNotChange()
        {
            var level0 = new ParametersDictionary();

            level0[keys[0]] = "key0_level0";
            level0[keys[1]] = "key1_level0";
            level0[keys[2]] = "key2_level0";
            level0[keys[3]] = "key3_level0";

            var level1 = new ViewPropertiesDictionary(level0);

            level1[keys[0]] = "key0_level1";
            level1[keys[4]] = "key4_level1";
            level1[keys[5]] = "key5_level1";
            level1[keys[6]] = "key6_level1";

            var level2 = new ViewPropertiesDictionary(level1);

            level2[keys[0]] = "key0_level2";
            level2[keys[1]] = "key1_level2";
            level2[keys[4]] = "key4_level2";
            level2[keys[7]] = "key7_level2";
            level2[keys[8]] = "key8_level2";

            var level3 = new ViewPropertiesDictionary(level2);

            level3[keys[0]] = "key0_level3";
            level3[keys[1]] = "key1_level3";
            level3[keys[2]] = "key2_level3";
            level3[keys[4]] = "key4_level3";
            level3[keys[7]] = "key7_level3";
            level3[keys[9]] = "key9_level3";


            // Level 0
            Assert.That(level0[keys[0]], Is.EqualTo("key0_level0"));
            Assert.That(level0[keys[1]], Is.EqualTo("key1_level0"));
            Assert.That(level0[keys[2]], Is.EqualTo("key2_level0"));
            Assert.That(level0[keys[3]], Is.EqualTo("key3_level0"));
            foreach (var i in Enumerable.Range(4, Range - 4))
            {
                Assert.That(level0.Contains(keys[i]), Is.Not.True);
            }

            // Level 1
            Assert.That(level1[keys[0]], Is.EqualTo("key0_level1"));
            Assert.That(level1[keys[1]], Is.EqualTo("key1_level0"));
            Assert.That(level1[keys[2]], Is.EqualTo("key2_level0"));
            Assert.That(level1[keys[3]], Is.EqualTo("key3_level0"));
            Assert.That(level1[keys[4]], Is.EqualTo("key4_level1"));
            Assert.That(level1[keys[5]], Is.EqualTo("key5_level1"));
            Assert.That(level1[keys[6]], Is.EqualTo("key6_level1"));
            foreach (var i in Enumerable.Range(7, Range - 7))
            {
                Assert.That(level1.Contains(keys[i]), Is.Not.True);
            }

            // Level 2
            Assert.That(level2[keys[0]], Is.EqualTo("key0_level2"));
            Assert.That(level2[keys[1]], Is.EqualTo("key1_level2"));
            Assert.That(level2[keys[2]], Is.EqualTo("key2_level0"));
            Assert.That(level2[keys[3]], Is.EqualTo("key3_level0"));
            Assert.That(level2[keys[4]], Is.EqualTo("key4_level2"));
            Assert.That(level2[keys[5]], Is.EqualTo("key5_level1"));
            Assert.That(level2[keys[6]], Is.EqualTo("key6_level1"));
            Assert.That(level2[keys[7]], Is.EqualTo("key7_level2"));
            Assert.That(level2[keys[8]], Is.EqualTo("key8_level2"));
            foreach (var i in Enumerable.Range(9, Range - 9))
            {
                Assert.That(level2.Contains(keys[i]), Is.Not.True);
            }

            // Level 3
            Assert.That(level3[keys[0]], Is.EqualTo("key0_level3"));
            Assert.That(level3[keys[1]], Is.EqualTo("key1_level3"));
            Assert.That(level3[keys[2]], Is.EqualTo("key2_level3"));
            Assert.That(level3[keys[3]], Is.EqualTo("key3_level0"));
            Assert.That(level3[keys[4]], Is.EqualTo("key4_level3"));
            Assert.That(level3[keys[5]], Is.EqualTo("key5_level1"));
            Assert.That(level3[keys[6]], Is.EqualTo("key6_level1"));
            Assert.That(level3[keys[7]], Is.EqualTo("key7_level3"));
            Assert.That(level3[keys[8]], Is.EqualTo("key8_level2"));
            Assert.That(level3[keys[9]], Is.EqualTo("key9_level3"));
            foreach (var i in Enumerable.Range(10, Range - 10))
            {
                Assert.That(level3.Contains(keys[i]), Is.Not.True);
            }
        }