/// <summary>
		/// </summary>
		/// <param name="context"></param>
		protected override void DoExecute(IMansionContext context)
		{
			// get the properties which to edit
			var properties = new PropertyBag(GetAttributes(context));
			properties.Remove("target");
			properties.Remove("global");
			using (context.Stack.Push("Properties", properties))
				ExecuteChildTags(context);

			// store the updated node
			var record = context.Repository.Create(context, properties);

			// push the new node to the stack
			context.Stack.Push(GetRequiredAttribute<string>(context, "target"), record, GetAttribute<bool>(context, "global")).Dispose();
		}
示例#2
0
        private static void FilterProperty(PropertyBag propertyBag, HashSet <string> attributesEverSet, SyncPropertyDefinition property)
        {
            bool flag = false;

            if (property.IsCalculated || !string.IsNullOrEmpty(property.LdapDisplayName))
            {
                if (property.IsCalculated)
                {
                    using (IEnumerator <ADPropertyDefinition> enumerator = property.DependentProperties.Cast <ADPropertyDefinition>().GetEnumerator())
                    {
                        while (enumerator.MoveNext())
                        {
                            ADPropertyDefinition adpropertyDefinition = enumerator.Current;
                            if (!string.IsNullOrEmpty(property.LdapDisplayName) && attributesEverSet.Contains(adpropertyDefinition.LdapDisplayName))
                            {
                                flag = true;
                                break;
                            }
                        }
                        goto IL_79;
                    }
                }
                flag = attributesEverSet.Contains(property.LdapDisplayName);
IL_79:
                if (!flag)
                {
                    propertyBag.Remove(property);
                }
            }
        }
示例#3
0
 // Token: 0x06001612 RID: 5650 RVA: 0x00052AB6 File Offset: 0x00050CB6
 public static void AppendForceToProxyCmdlet(PropertyBag parameters)
 {
     if (parameters.Contains("Force"))
     {
         parameters.Remove("Force");
     }
     parameters.Add("Force", true);
 }
示例#4
0
 public void Accept()
 {
     var updated = new PropertyBag(Get());
     Admixture.ForEach(kvp => updated.Add(kvp.Key, kvp.Value));
     Changes.ForEach(kvp => updated[kvp.Key] = kvp.Value);
     Leakage.ForEach(kvp => updated.Remove(kvp.Key));
     Set(updated);
 }
示例#5
0
 internal static void FaultInjection_Identity(PropertyBag parameters)
 {
     if (parameters.Contains("Identity"))
     {
         string value = parameters["Identity"].ToString();
         ExTraceGlobals.FaultInjectionTracer.TraceTest <string>(3519425853U, ref value);
         parameters.Remove("Identity");
         parameters.Add("Identity", value);
     }
 }
        public void UnlessWithIsDefine()
        {
            PropertyBag["isWeb"] = true;
            ProcessView("regressions/UnlessWithIsDefine");
            AssertReplyEqualTo("");

            PropertyBag.Remove("isWeb");
            ProcessView("regressions/UnlessWithIsDefine");
            AssertReplyEqualTo("isWeb is defined");
        }
示例#7
0
		/// <summary>
		/// </summary>
		/// <param name="context"></param>
		protected override void DoExecute(IMansionContext context)
		{
			// get arguments
			var parentSource = GetRequiredAttribute<Node>(context, "parentSource");

			// get the properties which to edit
			var newProperties = new PropertyBag(GetAttributes(context));
			newProperties.Remove("parentSource");
			newProperties.Remove("target");
			newProperties.Remove("global");
			using (context.Stack.Push("NewProperties", newProperties, false))
				ExecuteChildTags(context);

			// store the updated node
			var createdNode = context.Repository.CreateNode(context, parentSource, newProperties);

			// push the new node to the stack
			context.Stack.Push(GetRequiredAttribute<string>(context, "target"), createdNode, GetAttribute<bool>(context, "global")).Dispose();
		}
示例#8
0
        public void PropertyBag_ExternalModification_DeleteProperty()
        {
            var bag = new PropertyBag {
                { "foo", 123 }, { "bar", 456 }
            };

            engine.AddHostObject("bag", bag);
            Assert.AreEqual(456, engine.Evaluate("bag.bar"));
            bag.Remove("bar");
            Assert.AreSame(Undefined.Value, engine.Evaluate("bag.bar"));
        }
		/// <summary>
		/// </summary>
		/// <param name="context"></param>
		protected override void DoExecute(IMansionContext context)
		{
			// get arguments
			var record = GetRequiredAttribute<Record>(context, "source");

			// get the properties which to edit
			var editProperties = new PropertyBag(GetAttributes(context));
			editProperties.Remove("source");
			using (context.Stack.Push("Properties", editProperties))
				ExecuteChildTags(context);

			// store the updated node
			context.Repository.Update(context, record, editProperties);
		}
		/// <summary>
		/// 
		/// </summary>
		/// <param name="context"></param>
		/// <param name="queryBuilder"></param>
		/// <param name="newProperties"></param>
		protected override void DoToInsertStatement(IMansionContext context, ModificationQueryBuilder queryBuilder, IPropertyBag newProperties)
		{
			var extendedProperties = new PropertyBag(newProperties);
			// remove all properties starting with an underscore
			var unstoredPropertyNames = extendedProperties.Names.Where(candidate => candidate.StartsWith("_")).ToList();
			foreach (var propertyName in unstoredPropertyNames)
				extendedProperties.Remove(propertyName);

			// get the conversion service
			var conversionService = context.Nucleus.ResolveSingle<IConversionService>();

			// set the column value
			queryBuilder.AddColumnValue("extendedProperties", conversionService.Convert<byte[]>(context, extendedProperties), DbType.Binary);
		}
            private void RenderMetadata(TestStepRun testStepRun)
            {
                PropertyBag visibleEntries = testStepRun.Step.Metadata.Copy();

                visibleEntries.Remove(MetadataKeys.TestKind);

                if (visibleEntries.Keys.Count > 0)
                {
                    writer.Write("<ul class=\"metadata\">");
                    foreach (string key in visibleEntries.Keys)
                    {
                        RenderMetadataValues(key, visibleEntries[key]);
                    }
                    writer.Write("</ul>");
                }
            }
示例#12
0
        /// <summary>
        /// Evaluates the component's body providing a <c>page</c>
        /// instance which is a <see cref="IJSGenerator"/>
        /// </summary>
        /// <returns></returns>
        protected string GenerateJS()
        {
            var viewEngManager       = EngineContext.Services.ViewEngineManager;
            var viewEngine           = Context.ViewEngine;
            var currentController    = EngineContext.CurrentController;
            var currentControllerCtx = EngineContext.CurrentControllerContext;

            var jsCodeGen =
                viewEngManager.CreateJSCodeGeneratorInfo(EngineContext, currentController, currentControllerCtx);

            var generator = viewEngine.CreateJSGenerator(jsCodeGen, EngineContext, currentController, currentControllerCtx);

            PropertyBag["page"] = generator;

            Context.RenderBody(new StringWriter());             // Just for evaluation of generator

            PropertyBag.Remove("page");

            return(generator.ToString());
        }
 protected override bool ProcessInternal(PropertyBag propertyBag)
 {
     foreach (KeyValuePair <ADPropertyDefinition, RecipientTypeDetails> keyValuePair in this.filterMap)
     {
         ADPropertyDefinition key   = keyValuePair.Key;
         RecipientTypeDetails value = keyValuePair.Value;
         if (RecipientTypeSpecificPropertyFilter.ShouldFilterOutProperty(propertyBag, key, value))
         {
             ExTraceGlobals.BackSyncTracer.TraceDebug <string, object, RecipientTypeDetails>((long)SyncConfiguration.TraceId, "RecipientTypeSpecificPropertyFilter:: - Removing property {0} from object {1}. It should not be backsycned for recipient of type {2}.", key.Name, propertyBag[ADObjectSchema.Id], value);
             bool isReadOnly = propertyBag.IsReadOnly;
             try
             {
                 propertyBag.SetIsReadOnly(false);
                 propertyBag.Remove(key);
             }
             finally
             {
                 propertyBag.SetIsReadOnly(isReadOnly);
             }
         }
     }
     return(true);
 }
示例#14
0
 public void PropertyBag_ExternalModification_DeleteProperty()
 {
     var bag = new PropertyBag { { "foo", 123 }, { "bar", 456 } };
     engine.AddHostObject("bag", bag);
     Assert.AreEqual(456, engine.Evaluate("bag.bar"));
     bag.Remove("bar");
     Assert.AreSame(Undefined.Value, engine.Evaluate("bag.bar"));
 }
 public bool Remove(string key)
 {
     return(PropertyBag.Remove(key));
 }