public bool Validate(DependencyItem componentItem)
{
if (componentItem.MinVersion.CompareTo(Version(componentItem.Id)) <= 0 &&
componentItem.MaxVersion.CompareTo(Version(componentItem.Id)) >= 0)
return true;
return false;
}
/// <summary>
/// Constuctor.
/// </summary>
/// <param name="viewModelStore">The store this view model belongs to.</param>
/// <param name="dependencyItem">The model element that is hosted by this view model.</param>
/// <param name="bSubscribeToEvents">True if updates on elements name changes are needed.</param>
public DependencyItemViewModel(ViewModelStore viewModelStore, DependencyItem dependencyItem, bool bSubscribeToEvents)
: base(viewModelStore)
{
if (dependencyItem == null)
{
throw new ArgumentNullException("dependencyItem");
}
this.dependencyItem = dependencyItem;
this.doSubscribeToEvents = bSubscribeToEvents;
if (this.doSubscribeToEvents)
{
// subscribe
if (LanguageDSLElementNameProvider.Instance.HasName(dependencyItem.SourceElement))
{
DomainPropertyInfo info = LanguageDSLElementNameProvider.Instance.GetNamePropertyInfo(dependencyItem.SourceElement);
this.ViewModelStore.EventManager.GetEvent <ModelElementPropertyChangedEvent>().Subscribe(info, dependencyItem.SourceElement.Id, OnSourceNamePropertyChanged);
}
if (LanguageDSLElementNameProvider.Instance.HasName(dependencyItem.TargetElement))
{
DomainPropertyInfo info = LanguageDSLElementNameProvider.Instance.GetNamePropertyInfo(dependencyItem.TargetElement);
this.ViewModelStore.EventManager.GetEvent <ModelElementPropertyChangedEvent>().Subscribe(info, dependencyItem.TargetElement.Id, OnTargetNamePropertyChanged);
}
}
}
private void ResolveDependencies(DependencyItem target, List <DependencyItem> mainList, List <char> resolvedDependencies)
{
if (!resolvedDependencies.Contains(target.Name))
{
resolvedDependencies.Add(target.Name);
}
if (target.RawDependencyList.All(x => resolvedDependencies.Contains(x)))
{
return;
}
foreach (var item in target.RawDependencyList)
{
if (!mainList.Any(x => x.Name == item))
{
if (!resolvedDependencies.Contains(item))
{
resolvedDependencies.Add(item);
}
continue;
}
ResolveDependencies(mainList.First(x => x.Name == item), mainList, resolvedDependencies);
}
}
public void StoreDependency(DependencyItem item)
{
var dependency = new DependencyTelemetry
{
Data = item.Description,
Duration = item.Duration,
Name = item.Name,
Success = item.IsSucess,
Timestamp = item.StartTime,
Type = item.Type
};
if (item.Metrics?.Count > 0)
{
foreach (var metric in item.Metrics)
{
dependency.Metrics.Add(metric.Key, metric.Value);
}
}
if (item.Properties?.Count > 0)
{
foreach (var prop in item.Properties)
{
dependency.Properties.Add(prop.Key, prop.Value);
}
}
_telemetryClient.TrackDependency(dependency);
}
/// <summary>
/// Obtains dependencies (predecessors/succcesors) for the given PBI, and raises an event informing about this.
/// </summary>
/// <param name="pbiId">Product Backlog Item Id</param>
public void ImportDependenciesFromTfs(int pbiId)
{
try
{
this.RaiseDependenciesModelAboutToChange();
byte successorsDepth = 3;
byte predecessorsDepth = 3;
var workItem = this.WorkItemStore.GetWorkItem(pbiId);
var theModel = new Dictionary <int, DependencyItem>();
DependencyItem mainDependencyItem = new DependencyItem(pbiId)
{
Title = workItem.Title, State = workItem.State, Comment = Path.GetFileName(workItem.IterationPath)
};
mainDependencyItem.Tags.AddRange(TfsHelper.GetTags(workItem));
theModel.Add(pbiId, mainDependencyItem);
this.GetPredecessorsRec(theModel, workItem, predecessorsDepth);
this.GetSuccessorsRec(theModel, workItem, successorsDepth);
this.DependenciesModel = theModel;
this.RaiseDependenciesModelChanged();
}
catch (Exception ex)
{
this.Logger.Error(string.Format(@"{0}{1}{2}", ex.Message, Environment.NewLine, ex.StackTrace));
this.RaiseDependenciesModelCouldNotBeChanged();
throw;
}
}
private void listDependencies_MouseDown(object sender, MouseEventArgs e)
{
var hitInfo = listDependencies.HitTest(e.Location);
if (hitInfo.Item != null)
{
DependencyItem depItem = (DependencyItem)hitInfo.Item.Tag;
if (hitInfo.SubItem == hitInfo.Item.SubItems[2])
{
// dependent
depItem.DependencyInfo.Dependent = !depItem.DependencyInfo.Dependent;
if (!depItem.DependencyInfo.Dependent)
{
depItem.DependencyInfo.IncludeSymbols = false;
}
Element.DocumentInfo.Project.SetModified();
listDependencies.Invalidate(hitInfo.Item.Bounds);
}
else if (hitInfo.SubItem == hitInfo.Item.SubItems[3])
{
// include symbols
if ((depItem.DependencyInfo.Dependent) &&
(depItem.CanIncludeSymbols))
{
depItem.DependencyInfo.IncludeSymbols = !depItem.DependencyInfo.IncludeSymbols;
Element.DocumentInfo.Project.SetModified();
listDependencies.Invalidate(hitInfo.Item.Bounds);
}
}
}
}
private void list_versions_SelectedIndexChanged(object sender, EventArgs e)
{
if (list_versions.SelectedItems.Count < 1)
{
groupBox1.Enabled = false;
return;
}
groupBox1.Enabled = true;
DependencyItem item = list_versions.SelectedItem as DependencyItem;
SelectedItem = null;
cmb_type.Text = item.Type;
chk_warn.Checked = item.WarnOnly;
UpdateControlStates();
txt_id.Text = item.Id;
txt_name.Text = item.Name;
txt_message.Text = item.Message;
txt_version1_min.Text = item.MinVersion.Major;
txt_version2_min.Text = item.MinVersion.Minor;
txt_version3_min.Text = item.MinVersion.Build;
txt_version4_min.Text = item.MinVersion.Revision;
txt_version1_max.Text = item.MaxVersion.Major;
txt_version2_max.Text = item.MaxVersion.Minor;
txt_version3_max.Text = item.MaxVersion.Build;
txt_version4_max.Text = item.MaxVersion.Revision;
SelectedItem = item;
if (MpeInstaller.VersionProviders.ContainsKey(cmb_type.Text))
{
lbl_ver.Text = MpeInstaller.VersionProviders[cmb_type.Text].Version(txt_id.Text).ToString();
}
}
/// <summary>
/// Clean up.
/// </summary>
protected override void OnDispose()
{
if (this.doSubscribeToEvents)
{
if (this.DependencyItem != null)
{
// unsubscribe
if ((dependencyItem.SourceElement is IDomainModelOwnable))
{
if ((dependencyItem.SourceElement as IDomainModelOwnable).DomainElementHasName)
{
DomainPropertyInfo info = this.ViewModelStore.GetDomainModelServices(dependencyItem.SourceElement).ElementNameProvider.GetNamePropertyInfo(dependencyItem.SourceElement);
this.ViewModelStore.EventManager.GetEvent <ModelElementPropertyChangedEvent>().Unsubscribe(info, dependencyItem.SourceElement.Id, OnSourceNamePropertyChanged);
}
}
if ((dependencyItem.TargetElement is IDomainModelOwnable))
{
if ((dependencyItem.TargetElement as IDomainModelOwnable).DomainElementHasName)
{
DomainPropertyInfo info = this.ViewModelStore.GetDomainModelServices(dependencyItem.TargetElement).ElementNameProvider.GetNamePropertyInfo(dependencyItem.TargetElement);
this.ViewModelStore.EventManager.GetEvent <ModelElementPropertyChangedEvent>().Unsubscribe(info, dependencyItem.TargetElement.Id, OnTargetNamePropertyChanged);
}
}
}
}
base.OnDispose();
this.dependencyItem = null;
}
public bool Validate(DependencyItem componentItem)
{
if (componentItem.MinVersion.CompareTo(Version(componentItem.Id)) <= 0 &&
componentItem.MaxVersion.CompareTo(Version(componentItem.Id)) >= 0)
{
return(true);
}
return(false);
}
public override bool Validate(DependencyItem dependency)
{
if (dependency.MinVersion < MinimumMPVersionRequired)
{
return(false);
}
return(base.Validate(dependency));
}
private static DependencyItem CreateStrictDependency(MpeCore.Interfaces.IVersionProvider depType)
{
DependencyItem depItem = new DependencyItem();
depItem.Type = depType.DisplayName;
depItem.WarnOnly = false;
depItem.MinVersion = depType.Version(null);
depItem.MaxVersion = depType.Version(null);
depItem.Name = depType.DisplayName;
return depItem;
}
private void testToolStripMenuItem_Click(object sender, EventArgs e)
{
ToolStripMenuItem menu = sender as ToolStripMenuItem;
IVersionProvider type = menu.Tag as IVersionProvider;
if (type != null)
{
var item = new DependencyItem(type.DisplayName);
Package.Dependencies.Add(item);
list_versions.Items.Add(item);
}
}
private void VerifyElement(ProjectElement element)
{
if ((element != Element) &&
(element.DocumentInfo.Type != ProjectElement.ElementType.FOLDER))
{
var dependencies = Element.DocumentInfo.Project.GetDependencies(element);
FileDependency.DependencyInfo depInfo = Element.ForcedDependency.FindDependency(element.DocumentInfo.Project.Settings.Name, element.Filename);
if (depInfo == null)
{
depInfo = new FileDependency.DependencyInfo(element.DocumentInfo.Project.Settings.Name, element.Filename, false, false);
}
bool isDependent = false;
foreach (var dependency in dependencies)
{
if (dependency.Filename == Element.Filename)
{
isDependent = true;
break;
}
}
if (!isDependent)
{
// not itself!
DependencyItem depItem = new DependencyItem(depInfo, element.DocumentInfo.Type == ProjectElement.ElementType.ASM_SOURCE);
ListViewItem item = new ListViewItem(element.DocumentInfo.Project.Settings.Name);
item.SubItems.Add(element.Filename);
if (Element.ForcedDependency.DependsOn(element.DocumentInfo.Project.Settings.Name, element.Filename))
{
item.SubItems.Add("1");
}
else
{
item.SubItems.Add("0");
}
if (depInfo.IncludeSymbols)
{
item.SubItems.Add("1");
}
else
{
item.SubItems.Add("0");
}
item.Tag = depItem;
listDependencies.Items.Add(item);
}
}
}
/// <summary>
/// Checks if package has a MediaPortal dependency.
/// </summary>
/// <returns>Returns true if package has the dependency</returns>
public bool CheckMPDependency(out DependencyItem dep)
{
MpeCore.Classes.VersionProvider.MediaPortalVersion MPDependency = new Classes.VersionProvider.MediaPortalVersion();
if (CheckDependency(MPDependency, out dep))
{
if (dep.MaxVersion.CompareTo(MPDependency.Version(null)) > 0)
{
dep.MaxVersion = MPDependency.Version(null);
}
return true;
}
return false;
}
/// <summary>
/// Checks if package has a dependency of the specified type.
/// </summary>
/// <param name="depType">Type of VersionProvider to check for</param>
/// <param name="depItem">Specific dependency item in dpendencies collection that is of the desired type</param>
/// <returns>Returns true if package has the dependency</returns>
public bool CheckDependency(MpeCore.Interfaces.IVersionProvider depType, out DependencyItem depItem)
{
depItem = null;
foreach (DependencyItem item in Dependencies.Items)
{
if (item.Type == depType.DisplayName)
{
depItem = item;
return true;
}
}
return false;
}
public bool Validate(DependencyItem componentItem)
{
if (componentItem.MinVersion.CompareTo(MinimumMPVersionRequired) < 0)
{
return(false);
}
if (Version(componentItem.Id).CompareTo(componentItem.MinVersion) >= 0 &&
Version(componentItem.Id).CompareTo(componentItem.MaxVersion) <= 0)
{
return(true);
}
return(false);
}
/// <summary>
/// Parse the version range as a <see cref="VersionRange"/>.
/// </summary>
/// <param name="packageDependency">The package dependency.</param>
/// <returns>The version range.</returns>
public static VersionRange ParseRange(this DependencyItem packageDependency)
{
// Server side treats invalid version ranges as empty strings.
// Source: https://github.com/NuGet/NuGet.Services.Metadata/blob/382c214c60993edfd7158bc6d223fafeebbc920c/src/Catalog/Helpers/NuGetVersionUtility.cs#L25-L34
// Client side treats empty string version ranges as the "all" range.
// Source: https://github.com/NuGet/NuGet.Client/blob/849063018d8ee08625774a2dcd07ab84224dabb9/src/NuGet.Core/NuGet.Protocol/DependencyInfo/RegistrationUtility.cs#L20-L30
// Example: https://api.nuget.org/v3/catalog0/data/2016.03.14.21.19.28/servicestack.extras.serilog.2.0.1.json
if (!VersionRange.TryParse(packageDependency.Range, out var parsed))
{
return(VersionRange.All);
}
return(parsed);
}
public RequirementsSection()
{
InitializeComponent();
SelectedItem = null;
foreach (var versionProvider in MpeInstaller.VersionProviders)
{
ToolStripMenuItem testToolStripMenuItem = new ToolStripMenuItem();
testToolStripMenuItem.Text = versionProvider.Value.DisplayName;
testToolStripMenuItem.Tag = versionProvider.Value;
testToolStripMenuItem.Click += testToolStripMenuItem_Click;
mnu_add.DropDownItems.Add(testToolStripMenuItem);
cmb_type.Items.Add(versionProvider.Value.DisplayName);
}
}
/// <summary>
/// This creates the dependency information after the reflection.
/// </summary>
/// <param name="dependencies"></param>
/// <param name="dependencyDir"></param>
private void CreateDependency(DependencyContent dependencies,
string dependencyDir)
{
if (dependencies == null || dependencies.Count == 0)
{
return;
}
int itemCount = dependencies.Count;
for (int i = 0; i < itemCount; i++)
{
DependencyItem dependency = dependencies[i];
if (dependency == null || dependency.IsEmpty)
{
continue;
}
string dependencyFile = dependency.Location;
// There is no need to include a reference assembly, if it is
// a dependent assembly...
//if (!String.IsNullOrEmpty(dependencyFile)
// && !_dictReference.ContainsKey(dependencyFile))
// However, for some cases, especially where there is redirection
// of assembly, the explicit dependency is still required...
if (!String.IsNullOrEmpty(dependencyFile))
{
string fileName = Path.GetFileName(dependencyFile);
fileName = Path.Combine(dependencyDir, fileName);
if (!File.Exists(fileName))
{
File.Copy(dependencyFile, fileName, true);
File.SetAttributes(fileName, FileAttributes.Normal);
// Set if the comment file exists and link it...
dependencyFile = Path.ChangeExtension(dependencyFile, ".xml");
if (File.Exists(dependencyFile))
{
_linkCommentFiles.Add(dependencyFile);
}
if (dependency.IsRedirected)
{
_bindingRedirects.Add(dependency);
}
}
}
}
}
private void SelectPivotItem(DependencyItem item)
{
if (m_history.Count == 0 && depSelect.SelectedItem != null)
{
m_history.Add(depSelect.SelectedItem);
}
SelectPivotItemCore(item);
if (m_historyPosition >= 0 && m_historyPosition < m_history.Count)
{
m_history.RemoveRange(m_historyPosition + 1, m_history.Count - m_historyPosition - 1);
}
m_history.Add(item);
m_historyPosition = m_history.Count - 1;
UpdateHistoryEnabling();
}
public static void Main(string[] args)
{
var inMemoryConnectionString = "Server=ALX-DEV;Database=AlexandraDemo;Trusted_Connection=True;Application Name=Bwaa;";
var _ = new DependencyItem(
data => Console.WriteLine($"Pre-patch dependency found the following connection string: {data}")
);
PatchConnectionString(inMemoryConnectionString);
var __ = new DependencyItem(
data => Console.WriteLine($"Post-patch dependency found the following connection string: {data}")
);
Console.WriteLine("Done.");
}
public override void OnClose()
{
Element.TargetFilename = editTargetFilename.Text;
Element.TargetType = (Types.CompileTargetType)comboTargetType.SelectedIndex;
// rebuild dependency list
Element.ForcedDependency.DependentOnFile.Clear();
foreach (ListViewItem item in listDependencies.Items)
{
DependencyItem depItem = (DependencyItem)item.Tag;
if (depItem.DependencyInfo.Dependent)
{
Element.ForcedDependency.DependentOnFile.Add(depItem.DependencyInfo);
}
}
}
/// <summary>
/// Constuctor.
/// </summary>
/// <param name="viewModelStore">The store this view model belongs to.</param>
/// <param name="dependencyItem">The model element that is hosted by this view model.</param>
/// <param name="bSubscribeToEvents">True if updates on elements name changes are needed.</param>
public DependencyItemViewModel(ViewModelStore viewModelStore, DependencyItem dependencyItem, bool bSubscribeToEvents)
: base(viewModelStore)
{
if (dependencyItem == null)
{
throw new ArgumentNullException("dependencyItem");
}
this.dependencyItem = dependencyItem;
this.doSubscribeToEvents = bSubscribeToEvents;
if (this.doSubscribeToEvents)
{
// subscribe
if ((dependencyItem.SourceElement is IDomainModelOwnable))
{
if ((dependencyItem.SourceElement as IDomainModelOwnable).DomainElementHasName)
{
DomainPropertyInfo info = this.ViewModelStore.GetDomainModelServices(dependencyItem.SourceElement).ElementNameProvider.GetNamePropertyInfo(dependencyItem.SourceElement);
this.ViewModelStore.EventManager.GetEvent <ModelElementPropertyChangedEvent>().Subscribe(info, dependencyItem.SourceElement.Id, OnSourceNamePropertyChanged);
}
}
if ((dependencyItem.TargetElement is IDomainModelOwnable))
{
if ((dependencyItem.TargetElement as IDomainModelOwnable).DomainElementHasName)
{
DomainPropertyInfo info = this.ViewModelStore.GetDomainModelServices(dependencyItem.TargetElement).ElementNameProvider.GetNamePropertyInfo(dependencyItem.TargetElement);
this.ViewModelStore.EventManager.GetEvent <ModelElementPropertyChangedEvent>().Subscribe(info, dependencyItem.TargetElement.Id, OnTargetNamePropertyChanged);
}
}
/*if (this.ViewModelStore.GetDomainModelServices(dependencyItem.SourceElement).ElementNameProvider.HasName(dependencyItem.SourceElement))
* {
* DomainPropertyInfo info = this.ViewModelStore.GetDomainModelServices(dependencyItem.SourceElement).ElementNameProvider.GetNamePropertyInfo(dependencyItem.SourceElement);
* this.ViewModelStore.EventManager.GetEvent<ModelElementPropertyChangedEvent>().Subscribe(info, dependencyItem.SourceElement.Id, OnSourceNamePropertyChanged);
* }
* if (this.ViewModelStore.GetDomainModelServices(dependencyItem.TargetElement).ElementNameProvider.HasName(dependencyItem.TargetElement))
* {
* DomainPropertyInfo info = this.ViewModelStore.GetDomainModelServices(dependencyItem.TargetElement).ElementNameProvider.GetNamePropertyInfo(dependencyItem.TargetElement);
* this.ViewModelStore.EventManager.GetEvent<ModelElementPropertyChangedEvent>().Subscribe(info, dependencyItem.TargetElement.Id, OnTargetNamePropertyChanged);
* }*/
}
}
public void ImportDependenciesFromCsvFile(string csvFile)
{
try
{
this.RaiseDependenciesModelAboutToChange();
var engine = new FileHelperEngine <CsvDependency>();
var records = engine.ReadFile(csvFile);
if (engine.GetFileHeader() != engine.HeaderText.Trim())
{
throw new Exception(string.Format("[CSV] Column headers: '{0}' from file '{1}' do not match the expected ones: '{2}'", engine.HeaderText.Trim(), csvFile, engine.GetFileHeader()));
}
var theModel = new Dictionary <int, DependencyItem>();
DependencyItem tempItem;
foreach (var csvDependency in records)
{
tempItem = new DependencyItem(
csvDependency.Id,
csvDependency.Title,
csvDependency.Comment,
csvDependency.SuccessorIds ?? new List <int>(),
csvDependency.Tags ?? new List <string>());
tempItem.State = csvDependency.Status;
theModel.Add(csvDependency.Id, tempItem);
this.Logger.Debug(string.Format(@"[CSV] Got: {0}", tempItem.ToString()));
}
this.DependenciesModel = theModel;
this.RaiseDependenciesModelChanged();
}
catch (Exception ex)
{
this.Logger.Error(string.Format(@"{0}{1}{2}", ex.Message, Environment.NewLine, ex.StackTrace));
this.RaiseDependenciesModelCouldNotBeChanged();
throw;
}
}
private void testToolStripMenuItem_Click(object sender, EventArgs e)
{
ToolStripMenuItem menu = sender as ToolStripMenuItem;
IVersionProvider type = menu.Tag as IVersionProvider;
if (type != null)
{
var item = new DependencyItem(type.DisplayName)
{
MinVersion = type.Version(null), MaxVersion = type.Version(null)
};
if (type is MpeCore.Classes.VersionProvider.MediaPortalVersion)
{
item.Message = string.Format("This version of {0} requires MediaPortal {1} or higher!", Package.GeneralInfo.Name, MediaPortal.Common.Utils.CompatibilityManager.MediaPortalReleaseForApiVersion(new Version(item.MinVersion.ToString())));
}
Package.Dependencies.Add(item);
list_versions.Items.Add(item);
}
}
protected override void LoadDependencies()
{
if (!m_members.LoadDependencies)
{
return;
}
MsSqlSettings cfg = GlobalSettings.Pages.PageByName("mssql_client") as MsSqlSettings;
if (!cfg.UseNativeDependencies)
{
return;
}
foreach (SpecificObjectStructure obj in m_db.GetAllSpecificObjects())
{
obj.DependsOn = new List <DependencyItem>();
}
foreach (var row in CachedQueryRows(ReplaceMsSqlPlaceholders(StdScripts.getdepends)))
{
string mainspec = SysObjectsCategoryToSpecType(row.SafeString("MainType"));
NameWithSchema main = new NameWithSchema(row.SafeString("MainSchema"), row.SafeString("MainName"));
string refspec = SysObjectsCategoryToSpecType(row.SafeString("RefType"));
NameWithSchema refn = new NameWithSchema(row.SafeString("RefSchema"), row.SafeString("RefName"));
if (mainspec != null && refspec != null)
{
if (m_db.SpecificObjects.ContainsKey(mainspec) && m_db.SpecificObjects[mainspec].GetIndex(main) >= 0)
{
SpecificObjectStructure obj = (SpecificObjectStructure)m_db.SpecificObjects[mainspec][main];
var newdep = new DependencyItem {
Name = refn, ObjectType = refspec
};
if (!obj.DependsOn.Contains(newdep))
{
obj.DependsOn.Add(newdep);
}
}
}
}
}
private void GetPredecessorsRec(Dictionary <int, DependencyItem> model, WorkItem parent, byte level)
{
if (level == 0)
{
return;
}
level--;
DependencyItem innerDependencyItem;
var predecessors = this.GetPredecessorsFromTfs(parent);
foreach (var predecessor in predecessors)
{
innerDependencyItem = new DependencyItem(predecessor.Id)
{
Title = predecessor.Title, State = predecessor.State, Comment = Path.GetFileName(predecessor.IterationPath)
};
innerDependencyItem.Tags.AddRange(TfsHelper.GetTags(predecessor));
try
{
if (!model.ContainsKey(predecessor.Id))
{
model.Add(predecessor.Id, innerDependencyItem);
}
if (!model[predecessor.Id].Successors.Contains(parent.Id))
{
model[predecessor.Id].Successors.Add(parent.Id);
}
}
catch (Exception)
{
throw;
}
this.GetPredecessorsRec(model, predecessor, level);
}
}
/// <summary>
/// Clean up.
/// </summary>
protected override void OnDispose()
{
if (this.doSubscribeToEvents)
{
// unsubscribe
if (LanguageDSLElementNameProvider.Instance.HasName(dependencyItem.SourceElement))
{
DomainPropertyInfo info = LanguageDSLElementNameProvider.Instance.GetNamePropertyInfo(dependencyItem.SourceElement);
this.ViewModelStore.EventManager.GetEvent <ModelElementPropertyChangedEvent>().Unsubscribe(info, dependencyItem.SourceElement.Id, OnSourceNamePropertyChanged);
}
if (LanguageDSLElementNameProvider.Instance.HasName(dependencyItem.TargetElement))
{
DomainPropertyInfo info = LanguageDSLElementNameProvider.Instance.GetNamePropertyInfo(dependencyItem.TargetElement);
this.ViewModelStore.EventManager.GetEvent <ModelElementPropertyChangedEvent>().Unsubscribe(info, dependencyItem.TargetElement.Id, OnTargetNamePropertyChanged);
}
}
base.OnDispose();
this.dependencyItem = null;
}
private IReadOnlyList <DependencyGroupItem> ToDependencyItems(Package package)
{
List <DependencyGroupItem> groups = new List <DependencyGroupItem>();
var targetFrameworks = package.Dependencies.Select(a => a.TargetFramework).Distinct();
foreach (var tf in targetFrameworks)
{
var depGroupId = $"https://api.nuget.org/v3/catalog0/data/2015.02.01.06.24.15/{package.Id}.{package.Version}.json#dependencygroup/{tf}";
var dependencyItems = new List <DependencyItem>();
foreach (var dep in package.Dependencies.Where(a => a.TargetFramework == tf))
{
var depItem = new DependencyItem(depGroupId, dep.Id, dep.VersionRange);
dependencyItems.Add(depItem);
}
var groupItem = new DependencyGroupItem(depGroupId, tf, dependencyItems);
groups.Add(groupItem);
}
return(groups.Count > 0?groups.ToArray():null);
}
public void ResolveTargetDependencies(DependencyItem target, List <DependencyItem> dependencyList)
{
List <char> result = new List <char>();
foreach (var item in target.RawDependencyList)
{
if (!result.Contains(item))
{
result.Add(item);
}
if (!dependencyList.Any(x => x.Name == item))
{
continue;
}
ResolveDependencies(dependencyList.First(x => x.Name == item), dependencyList, result);
}
target.ParsedDependencyList = String.Concat(result);
}
public void DependencySortCycleTest()
{
var a = new DependencyItem() { Name = "a" };
var b = new DependencyItem() { Name = "b" };
var c = new DependencyItem() { Name = "c" };
var d = new DependencyItem() { Name = "d" };
var e = new DependencyItem() { Name = "e" };
a.Dependencies = new DependencyItem[] { d };
d.Dependencies = new DependencyItem[] { b, c };
b.Dependencies = new DependencyItem[] { a };
var items = new DependencyItem[] { a, b, c, d, e };
IList<DependencyItem> cycle = new List<DependencyItem>();
var sorted = InnovatorAdmin.Utils.DependencySort(items, dep => dep.Dependencies, ref cycle, false).ToList();
Assert.AreEqual(a, cycle[0]);
Assert.AreEqual(d, cycle[1]);
Assert.AreEqual(b, cycle[2]);
Assert.AreEqual(a, cycle[3]);
}
/// <summary>
/// Constuctor.
/// </summary>
/// <param name="viewModelStore">The store this view model belongs to.</param>
/// <param name="dependencyItem">The model element that is hosted by this view model.</param>
/// <param name="bSubscribeToEvents">True if updates on elements name changes are needed.</param>
public DependencyItemViewModel(ViewModelStore viewModelStore, DependencyItem dependencyItem, bool bSubscribeToEvents)
: base(viewModelStore)
{
if (dependencyItem == null)
throw new ArgumentNullException("dependencyItem");
this.dependencyItem = dependencyItem;
this.doSubscribeToEvents = bSubscribeToEvents;
if (this.doSubscribeToEvents)
{
// subscribe
if ((dependencyItem.SourceElement is IDomainModelOwnable))
if ((dependencyItem.SourceElement as IDomainModelOwnable).DomainElementHasName)
{
DomainPropertyInfo info = this.ViewModelStore.GetDomainModelServices(dependencyItem.SourceElement).ElementNameProvider.GetNamePropertyInfo(dependencyItem.SourceElement);
this.ViewModelStore.EventManager.GetEvent<ModelElementPropertyChangedEvent>().Subscribe(info, dependencyItem.SourceElement.Id, OnSourceNamePropertyChanged);
}
if ((dependencyItem.TargetElement is IDomainModelOwnable))
if ((dependencyItem.TargetElement as IDomainModelOwnable).DomainElementHasName)
{
DomainPropertyInfo info = this.ViewModelStore.GetDomainModelServices(dependencyItem.TargetElement).ElementNameProvider.GetNamePropertyInfo(dependencyItem.TargetElement);
this.ViewModelStore.EventManager.GetEvent<ModelElementPropertyChangedEvent>().Subscribe(info, dependencyItem.TargetElement.Id, OnTargetNamePropertyChanged);
}
/*if (this.ViewModelStore.GetDomainModelServices(dependencyItem.SourceElement).ElementNameProvider.HasName(dependencyItem.SourceElement))
{
DomainPropertyInfo info = this.ViewModelStore.GetDomainModelServices(dependencyItem.SourceElement).ElementNameProvider.GetNamePropertyInfo(dependencyItem.SourceElement);
this.ViewModelStore.EventManager.GetEvent<ModelElementPropertyChangedEvent>().Subscribe(info, dependencyItem.SourceElement.Id, OnSourceNamePropertyChanged);
}
if (this.ViewModelStore.GetDomainModelServices(dependencyItem.TargetElement).ElementNameProvider.HasName(dependencyItem.TargetElement))
{
DomainPropertyInfo info = this.ViewModelStore.GetDomainModelServices(dependencyItem.TargetElement).ElementNameProvider.GetNamePropertyInfo(dependencyItem.TargetElement);
this.ViewModelStore.EventManager.GetEvent<ModelElementPropertyChangedEvent>().Subscribe(info, dependencyItem.TargetElement.Id, OnTargetNamePropertyChanged);
}*/
}
}
public void DependencySortTest()
{
var a = new DependencyItem()
{
Name = "a"
};
var b = new DependencyItem()
{
Name = "b"
};
var c = new DependencyItem()
{
Name = "c"
};
var d = new DependencyItem()
{
Name = "d"
};
var e = new DependencyItem()
{
Name = "e"
};
a.Dependencies = new DependencyItem[] { b, d };
d.Dependencies = new DependencyItem[] { b, c };
b.Dependencies = new DependencyItem[] { e };
var items = new DependencyItem[] { a, b, c, d, e };
IList <DependencyItem> cycle = new List <DependencyItem>();
var sorted = InnovatorAdmin.Utils.DependencySort(items, dep => dep.Dependencies, ref cycle, false).ToList();
Assert.AreEqual(e, sorted[0]);
Assert.AreEqual(b, sorted[1]);
Assert.AreEqual(c, sorted[2]);
Assert.AreEqual(d, sorted[3]);
Assert.AreEqual(a, sorted[4]);
Assert.AreEqual(0, cycle.Count);
}
private void ReportDependencyCore(DependencyItem dependency)
{
if (IsValidDependency(dependency))
{
if (_dependencyItems.Add(dependency))
{
CreateOrUpdate(_indexOnFrom, dependency.From, dependency);
CreateOrUpdate(_indexOnReportedBy, dependency.ReportedBy, dependency);
Logger.LogDiagnostic($"Dependency item is successfully reported: {JsonUtility.Serialize(dependency)}.");
}
}
}
/// <summary>
/// Clean up.
/// </summary>
protected override void OnDispose()
{
if (this.doSubscribeToEvents)
if (this.DependencyItem != null)
{
// unsubscribe
if ((dependencyItem.SourceElement is IDomainModelOwnable))
if ((dependencyItem.SourceElement as IDomainModelOwnable).DomainElementHasName)
{
DomainPropertyInfo info = this.ViewModelStore.GetDomainModelServices(dependencyItem.SourceElement).ElementNameProvider.GetNamePropertyInfo(dependencyItem.SourceElement);
this.ViewModelStore.EventManager.GetEvent<ModelElementPropertyChangedEvent>().Unsubscribe(info, dependencyItem.SourceElement.Id, OnSourceNamePropertyChanged);
}
if ((dependencyItem.TargetElement is IDomainModelOwnable))
if ((dependencyItem.TargetElement as IDomainModelOwnable).DomainElementHasName)
{
DomainPropertyInfo info = this.ViewModelStore.GetDomainModelServices(dependencyItem.TargetElement).ElementNameProvider.GetNamePropertyInfo(dependencyItem.TargetElement);
this.ViewModelStore.EventManager.GetEvent<ModelElementPropertyChangedEvent>().Unsubscribe(info, dependencyItem.TargetElement.Id, OnTargetNamePropertyChanged);
}
}
base.OnDispose();
this.dependencyItem = null;
}
public virtual bool Validate(DependencyItem dependency)
{
var version = Version(dependency.Id);
return (version >= dependency.MinVersion && version <= dependency.MaxVersion);
}
/// <summary>
/// Constuctor.
/// </summary>
/// <param name="viewModelStore">The store this view model belongs to.</param>
/// <param name="dependencyItem">The model element that is hosted by this view model.</param>
public DependencyItemViewModel(ViewModelStore viewModelStore, DependencyItem dependencyItem)
: this(viewModelStore, dependencyItem, false)
{
this.dependencyItem = dependencyItem;
}
public void ReportDependency(DependencyItem dependency)
{
if (dependency == null)
{
throw new ArgumentNullException(nameof(dependency));
}
ReportDependencyCore(dependency);
}
private bool IsValidDependency(DependencyItem dependency)
{
if (!_types.ContainsKey(dependency.Type))
{
Logger.LogWarning($"dependency type {dependency.Type} isn't registered yet.");
return false;
}
return true;
}
private static void CreateOrUpdate(Dictionary<string, HashSet<DependencyItem>> index, string key, DependencyItem value)
{
HashSet<DependencyItem> items;
if (!index.TryGetValue(key, out items))
{
items = new HashSet<DependencyItem>();
index[key] = items;
}
items.Add(value);
}
