///--------------------------------------------------------------------------------
/// <summary>This method updates the view model data and sends update command back
/// to the solution builder.</summary>
///--------------------------------------------------------------------------------
protected override void OnUpdate()
{
// send update for any updated children
foreach (StageTransitionViewModel item in StageTransitions)
{
if (item.IsEdited == true)
{
item.Update();
}
}
// send update for any new children
foreach (StageTransitionViewModel item in ItemsToAdd.OfType <StageTransitionViewModel>())
{
item.Update();
StageTransitions.Add(item);
}
ItemsToAdd.Clear();
// send delete for any deleted children
foreach (StageTransitionViewModel item in ItemsToDelete.OfType <StageTransitionViewModel>())
{
item.Delete();
StageTransitions.Remove(item);
}
ItemsToDelete.Clear();
// reset modified for children
foreach (StageTransitionViewModel item in StageTransitions)
{
item.ResetModified(false);
}
}
///--------------------------------------------------------------------------------
/// <summary>This method updates the view model data and sends update command back
/// to the solution builder.</summary>
///--------------------------------------------------------------------------------
protected override void OnUpdate()
{
// send update for any updated children
foreach (EntityReferenceViewModel item in EntityReferences)
{
if (item.IsEdited == true)
{
item.Update();
}
}
// send update for any new children
foreach (EntityReferenceViewModel item in ItemsToAdd.OfType <EntityReferenceViewModel>())
{
item.Update();
EntityReferences.Add(item);
}
ItemsToAdd.Clear();
// send delete for any deleted children
foreach (EntityReferenceViewModel item in ItemsToDelete.OfType <EntityReferenceViewModel>())
{
item.Delete();
EntityReferences.Remove(item);
}
ItemsToDelete.Clear();
// reset modified for children
foreach (EntityReferenceViewModel item in EntityReferences)
{
item.ResetModified(false);
}
}
public AddsEditsDeletesSet(
List <TItem> oldItems,
List <TItem> newItems,
Func <TItem, object> keySelector,
Func <TItem, TItem, bool> itemsAreEqualComparer,
Func <TItem, bool> itemCannotBeDeletedSelector = null)
{
OldItems = oldItems;
NewItems = newItems;
foreach (TItem newItem in newItems)
{
object newItemKey = keySelector(newItem);
TItem matchingOldItem = oldItems.FirstOrDefault(oldItem => keySelector(oldItem).Equals(newItemKey));
if (matchingOldItem == null)
{
// No matching old item - this is a new item
ItemsToAdd.Add(newItem);
}
else
{
// Found a matching old item
if (itemsAreEqualComparer(newItem, matchingOldItem))
{
// Items match - the item has not been changed
ItemsWithNoChanges.Add(new OldAndNew <TItem> {
Old = matchingOldItem, New = newItem
});
}
else
{
// Items don't match - there are changes
ItemsToChange.Add(new OldAndNew <TItem> {
Old = matchingOldItem, New = newItem
});
}
}
}
foreach (TItem oldItem in oldItems)
{
object oldItemKey = keySelector(oldItem);
TItem matchingNewItem = newItems.FirstOrDefault(newItem => keySelector(newItem).Equals(oldItemKey));
if (matchingNewItem == null)
{
// No matching new item - this item has been deleted
ItemsToDelete.Add(oldItem);
}
}
if (itemCannotBeDeletedSelector != null)
{
ItemsThatCannotBeDeleted = ItemsToDelete.Where(itemCannotBeDeletedSelector).ToList();
}
}
private static ItemsToAdd GenerateItemsToAddModel(List <QnAItem> qnaItemsToAdd)
{
var itemsToAddModel = new ItemsToAdd
{
qnaList = new KbItemToAdd[] { },
urls = new string[] { },
users = new object[] { }
};
var kbItemsToAdd = new List <KbItemToAdd>();
foreach (var qnaItem in qnaItemsToAdd)
{
var kbItem = new KbItemToAdd
{
answer = qnaItem.Answer,
metadata = new MetadataItem[] { },
questions = new string[] { }
};
var questions = qnaItem.Questions;
kbItem.questions = questions.ToArray();
var metadata = new List <MetadataItem>
{
new MetadataItem()
{
name = "itemid",
value = qnaItem.ItemId.ToString()
},
new MetadataItem()
{
name = "isactive",
value = qnaItem.IsActive.ToString()
}
};
foreach (var metaDataItem in qnaItem.Metadata)
{
var metaDataItemToAdd = new MetadataItem
{
name = metaDataItem.name,
value = metaDataItem.value
};
metadata.Add(metaDataItemToAdd);
}
kbItem.metadata = metadata.ToArray();
kbItemsToAdd.Add(kbItem);
}
itemsToAddModel.qnaList = kbItemsToAdd.ToArray();
return(itemsToAddModel);
}
///--------------------------------------------------------------------------------
/// <summary>This method adds a relationship to the view model.</summary>
///
/// <param name="relationship">The relationship to add.</param>
///--------------------------------------------------------------------------------
public void CreateRelationship(DiagramRelationshipViewModel relationship)
{
// add diagram relationship to solution diagram
DiagramRelationships.Add(relationship);
Items.Add(relationship);
// add to diagram relationships to add list
ItemsToAdd.Add(relationship);
Refresh(false);
}
private async void OnAdd()
{
OnInfoRequested(LanguageChanger.Instance["AddItemsVm_Code1"]);
await Task.Run(() =>
{
var result = _ioSecurity.RetrieveData();
if (result.MainResult.Success)
{
List <ProcessModel> list = (from item in ItemsToAdd
select _ioSecurity.CreateProcessModel(item).Data).ToList();
int itemsAdded = 0;
foreach (ProcessModel model in list)
{
if (!result.Data.Any(x => x.ProcessName.Equals(model.ProcessName, StringComparison.InvariantCultureIgnoreCase)))
{
result.Data.Add(model);
itemsAdded++;
}
}
if (itemsAdded > 0)
{
var addResult = _ioSecurity.StoreData(result.Data);
if (addResult.Success)
{
OnInfoRequested(LanguageChanger.Instance["AddItemsVm_Code2"]);
var refreshResult = _serviceLifetimeController.RefreshService();
if (refreshResult.Success)
{
OnInfoRequested(LanguageChanger.Instance["AddItemsVm_Code3"]);
}
else
{
OnError(refreshResult.ErrorMessage);
}
}
else
{
OnError(addResult.ErrorMessage);
}
}
else
{
OnInfoRequested(LanguageChanger.Instance["AddItemsVm_Code4"]);
}
}
else
{
OnError(LanguageChanger.Instance["AddItemsVm_Code5"]);
}
});
ItemsToAdd.Clear();
}
///--------------------------------------------------------------------------------
/// <summary>This method adds to Entity adds.</summary>
///--------------------------------------------------------------------------------
public void AddNewEntity()
{
EntityViewModel item = new EntityViewModel();
item.Entity = new Entity();
item.Entity.EntityID = Guid.NewGuid();
item.Entity.Feature = EditFeature;
item.Entity.FeatureID = EditFeature.FeatureID;
item.Entity.Solution = Solution;
item.Solution = Solution;
#region protected
#endregion protected
ItemsToAdd.Add(item);
Items.Add(item);
}
private void OnBrowse()
{
OpenFileDialog openFile = new OpenFileDialog()
{
FileName = "",
Filter = "Executable File (*.exe)|*.exe",
CheckFileExists = true,
CheckPathExists = true,
Multiselect = true
};
if (openFile.ShowDialog().Value)
{
foreach (var name in openFile.FileNames)
{
if (!name.ToLower().Contains("mgr21"))
{
ItemsToAdd.Add(name);
}
}
}
}
///--------------------------------------------------------------------------------
/// <summary>This method creates an entity and adds to the view model.</summary>
///
/// <param name="entity">The entity to add.</param>
/// <param name="position">The desired position to place the entity.</param>
///--------------------------------------------------------------------------------
public DiagramEntityViewModel CreateEntity(EntityViewModel entity, Point position)
{
// create diagram entity and add to solution diagram
DiagramEntity dropDiagram = new DiagramEntity();
dropDiagram.DiagramEntityID = Guid.NewGuid();
DiagramEntityViewModel diagramEntity = new DiagramEntityViewModel(dropDiagram, entity, this);
diagramEntity.X = Math.Max(0, position.X);
diagramEntity.Y = Math.Max(0, position.Y);
diagramEntity.Width = Double.NaN;
diagramEntity.Height = Double.NaN;
DiagramEntities.Add(diagramEntity);
Items.Add(diagramEntity);
ClearSelectedItems();
diagramEntity.IsSelected = true;
diagramEntity.ZIndex = ++ZIndex;
// add to diagram entites to add list
ItemsToAdd.Add(diagramEntity);
Refresh(false);
return(diagramEntity);
}
///--------------------------------------------------------------------------------
/// <summary>This method resets the items.</summary>
///--------------------------------------------------------------------------------
public void ResetItems()
{
if (ItemsToAdd.Count > 0)
{
foreach (WorkspaceViewModel item in ItemsToAdd)
{
Items.Remove(item);
item.Dispose();
}
ItemsToAdd.Clear();
}
if (ItemsToDelete.Count > 0)
{
foreach (WorkspaceViewModel item in ItemsToDelete)
{
Items.Add(item);
}
ItemsToDelete.Clear();
}
foreach (WorkspaceViewModel item in Items)
{
item.Reset();
}
}
///--------------------------------------------------------------------------------
/// <summary>This method puts an item into the add queue.</summary>
///
/// <param name="item">The item to add.</param>
///--------------------------------------------------------------------------------
public virtual void Add(WorkspaceViewModel item)
{
ItemsToAdd.Add(item);
Items.Add(item);
}
///--------------------------------------------------------------------------------
/// <summary>This method updates the view model data and sends update command back
/// to the solution builder.</summary>
///--------------------------------------------------------------------------------
protected override void OnUpdate()
{
// set up reverse engineering instance if not present
if (Feature.ReverseInstance == null && Feature.IsAutoUpdated == true)
{
Feature.ReverseInstance = new Feature();
Feature.ReverseInstance.TransformDataFromObject(Feature, null, false);
// perform the update of EditFeature back to Feature
Feature.TransformDataFromObject(EditFeature, null, false);
Feature.IsAutoUpdated = false;
}
else if (Feature.ReverseInstance != null)
{
EditFeature.ResetModified(Feature.ReverseInstance.IsModified);
if (EditFeature.Equals(Feature.ReverseInstance))
{
// perform the update of EditFeature back to Feature
Feature.TransformDataFromObject(EditFeature, null, false);
Feature.IsAutoUpdated = true;
}
else
{
// perform the update of EditFeature back to Feature
Feature.TransformDataFromObject(EditFeature, null, false);
Feature.IsAutoUpdated = false;
}
}
else
{
// perform the update of EditFeature back to Feature
Feature.TransformDataFromObject(EditFeature, null, false);
Feature.IsAutoUpdated = false;
}
Feature.ForwardInstance = null;
if (FeatureNameCustomized || DescriptionCustomized || TagsCustomized)
{
Feature.ForwardInstance = new Feature();
Feature.ForwardInstance.FeatureID = EditFeature.FeatureID;
Feature.SpecSourceName = Feature.DefaultSourceName;
if (FeatureNameCustomized)
{
Feature.ForwardInstance.FeatureName = EditFeature.FeatureName;
}
if (DescriptionCustomized)
{
Feature.ForwardInstance.Description = EditFeature.Description;
}
if (TagsCustomized)
{
Feature.ForwardInstance.Tags = EditFeature.Tags;
}
}
EditFeature.ResetModified(false);
OnUpdated(this, null);
// send update back to solution builder
SendEditFeaturePerformed();
// send update for any updated Entities
foreach (EntityViewModel item in Entities)
{
if (item.IsEdited == true)
{
item.Update();
}
}
// send update for any new Entities
foreach (EntityViewModel item in ItemsToAdd.OfType <EntityViewModel>())
{
item.Update();
Entities.Add(item);
}
// send delete for any deleted Entities
foreach (EntityViewModel item in ItemsToDelete.OfType <EntityViewModel>())
{
item.Delete();
Entities.Remove(item);
}
// reset modified for Entities
foreach (EntityViewModel item in Entities)
{
item.ResetModified(false);
}
ItemsToAdd.Clear();
ItemsToDelete.Clear();
}
private void OnRemove()
{
ItemsToAdd.Remove(SelectedItem);
}
