Example #1
0
 private static set GetSetFromRegistryObject(registry_object registryObject)
 {
     for (int i = 0; i <= registryObject.RegistryObjectItemsElementName.Count() - 1; i++)
     {
         if (registryObject.RegistryObjectItemsElementName[i] == registry_object_ItemsChoices.set)
         {
             return (set)registryObject.Items[i];
         }
     }
     return null;
 }
Example #2
0
        public static Dictionary<String, EntityObjectStringType> GetRegistryEntitiesFromObjectType(registry_object registryObject)
        {
            string hiveEntityName = registry_object_ItemsChoices.hive.ToString();
            string keyEntityName = registry_object_ItemsChoices.key.ToString();
            string nameEntityName = registry_object_ItemsChoices.name.ToString();

            object[] allEntities = registryObject.Items.ToArray();
            string[] allEntityNames = registryObject.RegistryObjectItemsElementName.Select(i => i.ToString()).ToArray<String>();

            Dictionary<String, EntityObjectStringType> registryEntities = new Dictionary<String, EntityObjectStringType>();
            registryEntities.Add(hiveEntityName, OvalHelper.GetEntityObjectByName(hiveEntityName, allEntities, allEntityNames));
            registryEntities.Add(keyEntityName, OvalHelper.GetEntityObjectByName(keyEntityName, allEntities, allEntityNames));
            registryEntities.Add(nameEntityName, OvalHelper.GetEntityObjectByName(nameEntityName, allEntities, allEntityNames));

            return registryEntities;
        }
Example #3
0
        public void Should_be_possible_to_get_EntityBaseType_from_an_object_that_have_multiples_items_that_is_not_EntityBaseType()
        {         
            registry_object registry = new registry_object();

            IEnumerable<EntitySimpleBaseType> entities = registry.GetEntityBaseTypes();
            Assert.AreEqual(entities.Count(), 0, "the quantity is no expected");

            registry = new registry_object()
            {
                Items = new[] { new RegistryBehaviors() }
            };

            entities = registry.GetEntityBaseTypes();
            Assert.AreEqual(entities.Count(), 0, "the quantity is no expected");
        }
Example #4
0
 //[TestMethod]
 //public void TestFoo()
 //{
 //    string strComputer = ".";
 //    ManagementObjectSearcher wmiObjectSearcher = new ManagementObjectSearcher();
 //    wmiObjectSearcher.Scope = new ManagementScope("\\\\" + strComputer + "\\root\\directory\\LDAP");
 //    wmiObjectSearcher.Query = new ObjectQuery("Select * from ads_domaindns");
 //    wmiObjectSearcher.Options = new EnumerationOptions() { Rewindable = false, ReturnImmediately = true };
 //    string result = string.Empty;
 //    foreach (var obj in wmiObjectSearcher.Get())
 //        foreach (PropertyData property in obj.Properties)
 //        {
 //            string propertyValue = (property.Value == null) ? "[NULL]" : property.Value.ToString();
 //            result += string.Format("Property Name: '{0}' / Property Value: {1}\r\n", property.Name, propertyValue);
 //        }
 //    System.IO.File.WriteAllText("c:\\temp\\DomainDNS.txt", result);
 //    Assert.IsTrue(true);
 //}
 private EntityObjectStringType getRegistryObjectEntity(registry_object registryObject, string entityName)
 {
     Dictionary<string, EntityObjectStringType> entities = OvalHelper.GetRegistryEntitiesFromObjectType(registryObject);
     return entities[entityName];
 }
Example #5
0
        /// <summary>
        /// Creates the registry object given the oval Registry Object.
        /// </summary>
        /// <param name="ovalRegistryObject">The oval registry object.</param>
        /// <returns></returns>
        public static RegistryObject CreateRegistryObject(registry_object ovalRegistryObject)
        {
            Dictionary<String, EntityObjectStringType> allRegistryEntities = OvalHelper.GetRegistryEntitiesFromObjectType(ovalRegistryObject);
            return new RegistryObject(allRegistryEntities);

        }
 /// <summary>
 /// Evaluates all the variables for registry object.
 /// One registry_object can create multiples RegistryObjects.
 /// This happen because the variable is defined in the RegistryEntity, and a variable can be have multiples values.
 /// </summary>
 /// <param name="registryObject">The registry object.</param>
 /// <returns></returns>
 public IEnumerable<RegistryObject> ProcessVariableForRegistryObject(registry_object registryObject)
 {
     var registry = RegistryObjectFactory.CreateRegistryObject(registryObject);
     return new List<RegistryObject>(this.ProcessVariables(registry));
 }