protected override IEnumerable <CollectedItem> collectDataForSystemItem(ItemType systemItem)
{
var filePath = string.Empty;
try
{
var fileContentItem = (textfilecontent_item)systemItem;
filePath = Path.Combine(fileContentItem.path.Value, fileContentItem.filename.Value);
var interimList = WinNetUtils.getWinTextFileContent(hostUNC, filePath, fileContentItem.line.Value);
var collectedItems = new List <CollectedItem>();
foreach (FileContentItemSystemData srcItem in interimList)
{
var destItem = new textfilecontent_item();
this.BuilderFileContentItem(destItem, srcItem, fileContentItem);
var newCollectedItem = new CollectedItem()
{
ItemType = destItem, ExecutionLog = BuildExecutionLog()
};
collectedItems.Add(newCollectedItem);
}
return(collectedItems);
}
catch (FileNotFoundException)
{
base.SetDoesNotExistStatusForItemType(systemItem, filePath);
}
return(new ItemTypeHelper().CreateCollectedItemsWithOneItem(systemItem, BuildExecutionLog()));
}
private void LoadCollectedItems(List <DataItem> dataItems)
{
var newItems = new List <CollectedItem>();
foreach (var dataItem in dataItems)
{
var item = new CollectedItem(dataItem);
newItems.Add(item.Copy());
}
foreach (var newItem in newItems)
{
if (!CollectedItems.ToList().Exists(x => x.Id == newItem.Id))
{
CollectedItems.Add(newItem);
}
}
foreach (var item in CollectedItems.ToList())
{
if (!newItems.Exists(x => x.Id == item.Id))
{
CollectedItems.Remove(item);
}
}
CollectedItems.SupressNotification = true;
CollectedItems.Sort();
CollectedItems.SupressNotification = false;
}
private void assertFileEffectiveRightsCollectedItems(CollectedItem expectedItem, ItemType collectedItem)
{
fileeffectiverights_item expectedFileItem = (fileeffectiverights_item)expectedItem.ItemType;
fileeffectiverights_item collectedFileItem = (fileeffectiverights_item)collectedItem;
Assert.AreEqual(expectedFileItem.trustee_sid.Value, collectedFileItem.trustee_sid.Value, string.Format(MSG_UNEXPECTED_COLLECTED_ENTITY_VALUE, "trustee_sid"));
}
public RunLevelProberTests()
{
FakeItemToCollect1 = CreateFakeRunlevelItem("ssh", "2", null, null);
FakeItemToCollect2 = CreateFakeRunlevelItem("cups", "3", null, null);
FakeCollectedItem1 = ProbeHelper.CreateFakeCollectedItem(CreateFakeRunlevelItem("ssh", "2", "0", "1"));
FakeCollectedItem2 = ProbeHelper.CreateFakeCollectedItem(CreateFakeRunlevelItem("cups", "3", "1", "0"));
}
void SaveCaptureItems(CaptureItem ci, Event e, DataTable dt)
{
string adr = "/GeneratedData/GeneratedEvents/Event||" + e.id.ToString("00") + "/Capture/Item";
int id = DataTable_Functions.TrakHound.GetUnusedAddressId(adr, dt);
adr = adr + "||" + id.ToString("00");
ci.id = id;
// Save Root
string attr = "";
attr += "id||" + ci.id.ToString("00") + ";";
attr += "name||" + ci.name.Replace(' ', '_').ToLower() + ";";
string link = ci.link;
List <CollectedItem> linkitems = CollectedItems.ToList();
CollectedItem dataitem = linkitems.Find(x => x.Display == link);
if (dataitem != null)
{
link = dataitem.Id;
}
attr += "link||" + link + ";";
DataTable_Functions.UpdateTableValue(dt, "address", adr, "attributes", attr);
}
public void Should_be_possible_to_collect_file_effective_rights()
{
#region File Effective Rights Object
//<fileeffectiverights_object id="oval:modulo:obj:7" version="1" xmlns="http://oval.mitre.org/XMLSchema/oval-definitions-5#windows">
// <path>c:\temp</path>
// <filename>file1.txt</filename>
// <trustee_name>mss\lfernandes</trustee_name>
//</fileeffectiverights_object>
#endregion
oval_definitions definitions = ProbeHelper.GetFakeOvalDefinitions("definitionsSimple.xml");
CollectInfo fakeCollectInfo = ProbeHelper.CreateFakeCollectInfo(definitions.objects, null, null);
Definitions::ObjectType fileEffectiveRightsObject = ProbeHelper.GetOvalComponentByOvalID(definitions, "oval:modulo:obj:7");
IEnumerable <CollectedItem> fakeCollectedItems = new CollectedItem[] { this.createFakeCollectedItem(fileEffectiveRightsObject) };
FileEffectiveRightsProber prober = this.createMockedFileEffectiveRightsProber(fakeCollectedItems);
ProbeResult result = prober.Execute(ProbeHelper.CreateFakeContext(), ProbeHelper.CreateFakeTarget(), fakeCollectInfo);
Assert.IsNotNull(result, "The result of FileEffectiveRightsProber execution cannot be null.");
Assert.IsNotNull(result.ExecutionLog, "The ExecutionLog of FileEffectiveRightsProber was not created.");
Assert.IsNotNull(result.CollectedObjects, "There are no collected objects.");
Assert.AreEqual(1, result.CollectedObjects.Count(), "Unexpected collected objects count found.");
this.AssertCollectedFileItems(fileEffectiveRightsObject, result.CollectedObjects.ElementAt(0), fakeCollectedItems);
}
public void Should_be_possible_to_collect_SIDObject_for_given_trusteeName()
{
IList <WmiObject> fakeWmiObjects = new List <WmiObject>();
fakeWmiObjects.Add(this.createFakeWmiObject("MSS", "lfernandes", "FALSE", "Win32_UserAccount"));
SIDObjectCollector systemDataSource = this.CreateMockedSIDSystemDatasource(fakeWmiObjects);
string expectedSID = fakeWmiObjects[0].GetValueOf("SID").ToString();
IEnumerable <CollectedItem> collectedItems = systemDataSource.CollectDataForSystemItem(this.createFakeSidItem());
Assert.IsNotNull(collectedItems, "The collected items cannot be null.");
Assert.AreEqual(1, collectedItems.Count(), "Unexpected collected items count.");
CollectedItem collectedItem = collectedItems.First();
Assert.IsNotNull(collectedItem.ExecutionLog, "The execution log cannot be null.");
Assert.AreEqual(1, collectedItem.ExecutionLog.Count(), "Unexpected execution log count.");
Assert.AreEqual(TypeItemLog.Info, collectedItem.ExecutionLog.First().Type, "The type of execution log should be Info.");
Assert.IsInstanceOfType(collectedItem.ItemType, typeof(sid_item), "The type of collected item type should be 'sid_item'.");
Assert.AreEqual(StatusEnumeration.exists, collectedItem.ItemType.status, "The status of collected item should be 'exists'.");
Assert.AreEqual("lfernandes", ((sid_item)collectedItem.ItemType).trustee_name.Value, "Unexpected trustee name was found on collected SID Item.");
Assert.AreEqual("MSS", ((sid_item)collectedItem.ItemType).trustee_domain.Value, "Unexpected trustee domain was found on collected SID Item.");
Assert.AreEqual(expectedSID, ((sid_item)collectedItem.ItemType).trustee_sid.Value, "Unexpected trustee SID was found on collected SID Item.");
}
private RegistryProber GetMockedRegistryProber(registry_item fakeItem)
{
var fakeValues = new List <String>(new string[] { "FakeValue" });
var fakeCollectedItems = new CollectedItem[] { ProbeHelper.CreateFakeCollectedItem(fakeItem) };
MockRepository mocks = new MockRepository();
var fakeConnection = mocks.DynamicMock <IConnectionManager>();
var fakeSystemInformation = mocks.DynamicMock <ISystemInformationService>();
var fakeProvider = mocks.DynamicMock <RegistryConnectionProvider>();
var fakeWmiProvider = new WmiDataProviderExpectFactory().GetFakeWmiDataProviderForTestInvokeMethodEnumKeyWithReturnSuccess();
var fakeDataCollector = mocks.DynamicMock <RegistryObjectCollector>();
fakeDataCollector.WmiDataProvider = fakeWmiProvider;
var registryItemTypeGeneration = new RegistryItemTypeGenerator()
{
SystemDataSource = fakeDataCollector, WmiDataProvider = fakeWmiProvider
};
Expect.Call(fakeConnection.Connect <RegistryConnectionProvider>(null, null)).IgnoreArguments().Repeat.Any().Return(fakeProvider);
Expect.Call(fakeDataCollector.CollectDataForSystemItem(fakeItem)).IgnoreArguments().Repeat.Any().Return(fakeCollectedItems);
Expect.Call(fakeDataCollector.GetValues(null)).IgnoreArguments().Repeat.Any().Return(fakeValues);
Expect.Call(fakeSystemInformation.GetSystemInformationFrom(null)).IgnoreArguments().Return(SystemInformationFactory.GetExpectedSystemInformation());
mocks.ReplayAll();
return(new RegistryProber()
{
ConnectionManager = fakeConnection, ObjectCollector = fakeDataCollector, ItemTypeGenerator = registryItemTypeGeneration
});
}
private FileProber GetMockedFileProber(file_item fakeItem)
{
IList <String> fakeValues = new List <String>(new string[] { "FakeValue" });
CollectedItem fakeCollectedItem = ProbeHelper.CreateFakeCollectedItem(fakeItem);
MockRepository mocks = new MockRepository();
IConnectionManager fakeConnection = mocks.DynamicMock <IConnectionManager>();
ISystemInformationService fakeSystemInformation = mocks.DynamicMock <ISystemInformationService>();
FileConnectionProvider fakeProvider = mocks.DynamicMock <FileConnectionProvider>();
WmiDataProvider fakeWmiProvider = mocks.DynamicMock <WmiDataProvider>();
FileObjectCollector fakeDataCollector = mocks.DynamicMock <FileObjectCollector>();
fakeDataCollector.WmiDataProvider = fakeWmiProvider;
//Expect.Call(fakeConnection.Connect<FileConnectionProvider>(null, null)).IgnoreArguments().Repeat.Any().Return(fakeProvider);
Expect.Call(fakeDataCollector.CollectDataForSystemItem(fakeItem)).IgnoreArguments().Repeat.Any().Return(new List <CollectedItem>()
{
fakeCollectedItem
});
Expect.Call(fakeDataCollector.GetValues(null)).IgnoreArguments().Repeat.Any().Return(fakeValues);
Expect.Call(fakeSystemInformation.GetSystemInformationFrom(null)).IgnoreArguments().Return(SystemInformationFactory.GetExpectedSystemInformation());
mocks.ReplayAll();
return(new FileProber()
{
ConnectionManager = fakeConnection, ObjectCollector = fakeDataCollector
});
}
public CollectedItem Copy()
{
var copy = new CollectedItem();
copy.Id = Id;
copy.Name = Name;
copy.Display = Display;
return(copy);
}
public void AddItem(CollectedItem item)
{
CollectedItemData itemData = item.Data;
itemData.UiElementRef = Instantiate(LayoutElementFab, UIInventoryItemsLayoutGroup.transform);
itemData.UiElementRef.GetComponent <Image>().sprite = itemData.Icon;
InventoryList.Add(itemData);
_pickUpSound.PlayOneShot(_pickUpSound.clip);
}
public RpmInfoProberTests()
{
FakeItemToCollect1 = CreateFakeRpmInfoItem("vbox", null, null, null, null, null);
FakeItemToCollect2 = CreateFakeRpmInfoItem("firefox", null, null, null, null, null);
var fakeCollectedItem1 = CreateFakeRpmInfoItem("vbox", "x86", "2010", "1020", "12345678", "1");
FakeCollectedItem1 = ProbeHelper.CreateFakeCollectedItem(fakeCollectedItem1);
var fakeCollectedItem2 = CreateFakeRpmInfoItem("firefox", "x86", "2010", "1020", "12345678", "1");
FakeCollectedItem2 = ProbeHelper.CreateFakeCollectedItem(fakeCollectedItem2);
}
public CollectedItem Copy()
{
var copy = new CollectedItem();
copy.Id = Id;
copy.Name = Name;
copy.Display = Display;
copy.Category = Category;
copy.Type = Type;
return(copy);
}
void SaveTrigger(Trigger t, Value v, Event e, DataTable dt, string addressPrefix)
{
if (t.link != null && t.modifier != null)
{
string adr = addressPrefix + "/Trigger";
int id = DataTable_Functions.TrakHound.GetUnusedAddressId(adr, dt);
adr = adr + "||" + id.ToString("00");
t.id = id;
// Save Root
string attr = "";
attr += "id||" + t.id.ToString("00") + ";";
string link = t.link;
List <CollectedItem> linkitems = CollectedItems.ToList();
CollectedItem dataitem = linkitems.Find(x => x.Display == link);
if (dataitem != null)
{
link = dataitem.Id;
}
attr += "link||" + link + ";";
attr += "link_type||" + t.linkType + ";";
if (t.modifier != null)
{
switch (t.modifier)
{
case "Not Equal To": attr += "modifier||" + "not" + ";"; break;
case "Greater Than": attr += "modifier||" + "greater_than" + ";"; break;
case "Less Than": attr += "modifier||" + "less_than" + ";"; break;
case "Contains": attr += "modifier||" + "contains" + ";"; break;
case "Contains Match Case": attr += "modifier||" + "contains_match_case" + ";"; break;
case "Contains Whole Word": attr += "modifier||" + "contains_whole_word" + ";"; break;
case "Contains Whole Word Match Case": attr += "modifier||" + "contains_whole_word_match_case" + ";"; break;
}
}
attr += "value||" + t.value + ";";
DataTable_Functions.UpdateTableValue(dt, "address", adr, "attributes", attr);
}
}
public void The_operation_evaluator_of_TextFileContentItemTypeGenerator_must_be_configured()
{
var objectType = ProbeHelper.GetDefinitionObjectTypeByID("definitionsSimple", "900");
var fakeCollectInfo = ProbeHelper.CreateFakeCollectInfo(new Definitions.ObjectType[] { objectType }, null, null);
var fakeCollectedItems = new CollectedItem[] { ProbeHelper.CreateFakeCollectedItem(new textfilecontent_item()) };
var textFileContentProber = CreateMockedProberWithNoFakeItemTypeGenerator(fakeCollectedItems);
textFileContentProber.Execute(FakeContext, FakeTargetInfo, fakeCollectInfo);
Assert.IsInstanceOfType(textFileContentProber.ItemTypeGenerator, typeof(TextFileContentItemTypeGenerator));
var itemTypeGenerator = (TextFileContentItemTypeGenerator)textFileContentProber.ItemTypeGenerator;
Assert.IsNotNull(itemTypeGenerator.OperationEvaluator);
}
public void Should_be_possible_to_collect_wmi_object()
{
var fakeItemsToReturn = this.CreateWmiItems(FAKE_WMI_NAMESPACE, FAKE_WQL);
var fakeCollectedItems = new CollectedItem[] { ProbeHelper.CreateFakeCollectedItem(fakeItemsToReturn.First()) };
var fakeCollectedInfo = GetFakeCollectInfo("oval:modulo:obj:2200");
ProberBehaviorCreator
.CreateBehaviorForNormalFlowExecution(
WMIProber,
fakeItemsToReturn,
fakeCollectedItems);
var proberExecutionResult = WMIProber.Execute(FakeContext, FakeTargetInfo, fakeCollectedInfo);
DoAssertForSingleCollectedObject(proberExecutionResult, typeof(wmi_item));
}
private void AssertCollectedFileItems(Definitions::ObjectType sourceObject, CollectedObject collectedObject, IEnumerable <CollectedItem> expectedItems)
{
SystemCharacteristics.ReferenceType[] objectReferences = collectedObject.ObjectType.reference.ToArray();
IList <ItemType> collectedItems = (IList <ItemType>)collectedObject.SystemData;
this.assertCollectedItemsReferences(collectedObject, collectedItems);
for (int i = 0; i < expectedItems.Count(); i++)
{
CollectedItem expectedFileItem = expectedItems.ElementAt(i);
ItemType collectedItem = collectedItems[i];
this.assertCollectedItemStatus(objectReferences[i], collectedItem);
this.assertFileEffectiveRightsInitialEntities(sourceObject, collectedItem);
this.assertFileEffectiveRightsCollectedItems(expectedFileItem, collectedItem);
}
}
public void Should_be_possible_to_execute_a_collect_for_RegKeyEffectiveRights_with_referenced_variable_on_key_entity()
{
var fakeObjects = new Definitions.ObjectType[] { ProbeHelper.GetDefinitionObjectTypeByID("definitionsSimple", "770") };
string fakeVariableValue = @"SOFTWARE\Microsoft\Windows NT\CurrentVersion";
var fakeEvaluatedVariables = VariableHelper.CreateVariableWithOneValue("oval:modulo:obj:770", "oval:modulo:var:770", fakeVariableValue);
var fakeCollectInfo = ProbeHelper.CreateFakeCollectInfo(fakeObjects, fakeEvaluatedVariables, null);
var fakeCollectedItems = new CollectedItem[] { ProbeHelper.CreateFakeCollectedItem(new regkeyeffectiverights_item()) };
var prober = this.GetMockedRegKeyEffectiveRightsProber(fakeCollectedItems, null);
var proberExecutionResult = prober.Execute(FakeContext, FakeTargetInfo, fakeCollectInfo);
this.doBasicProbeResultAssert(proberExecutionResult);
CollectedObject collectedObject = proberExecutionResult.CollectedObjects.Single(obj => obj.ObjectType.id.Equals("oval:modulo:obj:770"));
this.assertCollectedItemsReferences(collectedObject, (IList <ItemType>)collectedObject.SystemData);
Assert.AreEqual(1, collectedObject.SystemData.Count, "Unexpected system data count.");
this.assertCollectedItemStatus(collectedObject.ObjectType.reference.ElementAt(0), collectedObject.SystemData[0]);
}
public void Should_be_possible_to_collect_file_object_for_unix_systems()
{
var fakeFileItemsToReturn = new ItemType[] { new unix.file_item()
{
filepath = OvalHelper.CreateItemEntityWithStringValue("/home/usr/readme")
} };
var fakeCollectedItemsToReturn = new CollectedItem[] { ProbeHelper.CreateFakeCollectedItem(CreateFileItem()) };
var unixFileProber = new FileProber();
ProberBehaviorCreator
.CreateBehaviorForNormalFlowExecution(
unixFileProber,
fakeFileItemsToReturn,
fakeCollectedItemsToReturn);
var result = unixFileProber.Execute(FakeContext, FakeTargetInfo, GetFakeCollectInfo("oval:modulo:obj:2", "definitions_all_unix"));
DoAssertForSingleCollectedObject(result, typeof(unix.file_item));
}
public void Should_be_possible_to_process_a_RegKeyEffectiveRightsObject_with_set_operation()
{
var definitions = ProbeHelper.GetFakeOvalDefinitions("definitionsSimple.xml");
var fakeObjects = this.GetFakeObjectsFromDefinitions(definitions, new string[] { "750", "751", "760" });
var fakeSysCharac = ProbeHelper.GetOvalSystemCharacteristicsFromFile("system_characteristics_with_sets.xml");
var fakeCollectInfo = ProbeHelper.CreateFakeCollectInfo(fakeObjects, null, fakeSysCharac);
var fakeCollectedItems = new CollectedItem[] { ProbeHelper.CreateFakeCollectedItem(new regkeyeffectiverights_item()) };
var prober = this.GetMockedRegKeyEffectiveRightsProber(fakeCollectedItems, null);
ProbeResult proberExecutionResult = prober.Execute(FakeContext, FakeTargetInfo, fakeCollectInfo);
this.doBasicProbeResultAssert(proberExecutionResult);
Assert.AreEqual(3, proberExecutionResult.CollectedObjects.Count(), "Unexpected collected objects count.");
var collectedObjFromObjectWithSet = proberExecutionResult.CollectedObjects.SingleOrDefault(obj => obj.ObjectType.id.Equals("oval:modulo:obj:760"));
Assert.IsNotNull(collectedObjFromObjectWithSet, "There are no collected objects generated from object type with set.");
var referencedItems = collectedObjFromObjectWithSet.ObjectType.reference;
Assert.AreEqual(2, referencedItems.Count(), "Unexpected collected object references count.");
Assert.AreEqual("761", referencedItems.ElementAt(0).item_ref, "Unexpected referenced item was found on collected object.");
Assert.AreEqual("762", referencedItems.ElementAt(1).item_ref, "Unexpected referenced item was found on collected object.");
var generatedItemFromObjectTypeWithSet = collectedObjFromObjectWithSet.SystemData;
Assert.IsNotNull(generatedItemFromObjectTypeWithSet, "No item type was found in collected object system data.");
Assert.AreEqual(2, generatedItemFromObjectTypeWithSet.Count, "Unexpected system data count.");
var firstRegKeyEffectiveRightsItem = (regkeyeffectiverights_item)generatedItemFromObjectTypeWithSet[0];
Assert.AreEqual("761", firstRegKeyEffectiveRightsItem.id, "Unexpected id for a item was found.");
Assert.AreEqual(@"SOFTWARE\Modulo\RiskManager", firstRegKeyEffectiveRightsItem.key.Value, "Unexpected entity item type value was found.");
Assert.AreEqual("0", firstRegKeyEffectiveRightsItem.key_enumerate_sub_keys.Value, "Unexpected entity item type value was found.");
var secondRegKeyEffectiveRightsItem = (regkeyeffectiverights_item)generatedItemFromObjectTypeWithSet[1];
Assert.AreEqual("762", secondRegKeyEffectiveRightsItem.id, "Unexpected id for a item was found.");
Assert.AreEqual(@"SOFTWARE\Modulo\RiskManagerNG", secondRegKeyEffectiveRightsItem.key.Value, "Unexpected entity item type value was found.");
Assert.AreEqual("1", secondRegKeyEffectiveRightsItem.key_enumerate_sub_keys.Value, "Unexpected entity item type value was found.");
}
private IEnumerable <CollectedItem> createFakeFamilyItem()
{
var familyItemType = new EntityItemFamilyType()
{
Value = "Windows"
};
var family = new family_item()
{
id = "1", family = familyItemType
};
var collectedItem = new CollectedItem()
{
ItemType = family, ExecutionLog = new List <ProbeLogItem>()
};
return(new List <CollectedItem>()
{
collectedItem
});
}
private void DoSave()
{
// do action
if (!Validate())
{
return;
}
var collectedItem = new CollectedItem()
{
Caption = Caption,
ImagePath = GenerateImagePath(),
Lat = Latitude,
Lng = Longitude,
LocationKnown = LocationKnown,
Notes = Notes,
WhenUtc = DateTime.UtcNow
};
_collectionService.Add(collectedItem);
Close(this);
}
private void LoadCollectedItems(List <MTConnectDevices.DataItem> dataItems)
{
var newItems = new List <CollectedItem>();
foreach (var dataItem in dataItems)
{
var item = new CollectedItem(dataItem);
newItems.Add(item.Copy());
}
foreach (var newItem in newItems)
{
if (!CollectedItems.ToList().Exists(x => x.Id == newItem.Id))
{
CollectedItems.Add(newItem);
}
}
foreach (var item in CollectedItems)
{
if (!newItems.Exists(x => x.Id == item.Id))
{
CollectedItems.Remove(item);
}
}
CollectedItems.SupressNotification = true;
CollectedItems.Sort();
CollectedItems.SupressNotification = false;
foreach (Controls.Event ev in events)
{
foreach (Controls.CaptureItem ci in ev.CaptureItems)
{
Dispatcher.BeginInvoke(new Action <Controls.CaptureItem>(CaptureItem_UpdateCollectedLink), priority, new object[] { ci });
}
}
}
private void LoadCollectedItems(List<DataItem> dataItems)
{
var newItems = new List<CollectedItem>();
foreach (var dataItem in dataItems)
{
var item = new CollectedItem(dataItem);
newItems.Add(item.Copy());
}
foreach (var newItem in newItems)
{
if (!CollectedItems.ToList().Exists(x => x.Id == newItem.Id)) CollectedItems.Add(newItem);
}
foreach (var item in CollectedItems)
{
if (!newItems.Exists(x => x.Id == item.Id)) CollectedItems.Remove(item);
}
CollectedItems.SupressNotification = true;
CollectedItems.Sort();
CollectedItems.SupressNotification = false;
foreach (Controls.Event ev in events)
{
foreach (Controls.CaptureItem ci in ev.CaptureItems)
{
Dispatcher.BeginInvoke(new Action<Controls.CaptureItem>(CaptureItem_UpdateCollectedLink), priority, new object[] { ci });
}
}
}
public CollectedItem Copy()
{
var copy = new CollectedItem();
copy.Id = Id;
copy.Name = Name;
copy.Display = Display;
copy.Category = Category;
copy.Type = Type;
return copy;
}
public void Add(CollectedItem item)
{
_repository.Add(item);
// TODO - send message telling people about the new item
}
public CollectedItem Copy()
{
var copy = new CollectedItem();
copy.Id = Id;
copy.Name = Name;
copy.Display = Display;
return copy;
}
private void LoadCollectedItems(List<DataItem> dataItems)
{
var newItems = new List<CollectedItem>();
foreach (var dataItem in dataItems)
{
var item = new CollectedItem(dataItem);
newItems.Add(item.Copy());
}
foreach (var newItem in newItems)
{
if (!CollectedItems.ToList().Exists(x => x.Id == newItem.Id)) CollectedItems.Add(newItem);
}
foreach (var item in CollectedItems)
{
if (!newItems.Exists(x => x.Id == item.Id)) CollectedItems.Remove(item);
}
CollectedItems.SupressNotification = true;
CollectedItems.Sort();
CollectedItems.SupressNotification = false;
}
public void Delete(CollectedItem item)
{
_repository.Delete(item);
_messenger.Publish(new CollectionChangedMessage(this));
}
public ProcessProberTests()
{
this.FakeProcessItem = new process_item();
this.FakeCollectedItem = ProbeHelper.CreateFakeCollectedItem(new OVAL.SystemCharacteristics.Unix.process_item());
}
