public void CompareLeftNull()
{
SemanticVersion right = new SemanticVersion(1, 0, 0);
VersionComparer comparer = new VersionComparer();
Assert.Equal(-1, comparer.Compare(null, right));
}
public void CompareRightNull()
{
SemanticVersion left = new SemanticVersion(1, 0, 0);
VersionComparer comparer = new VersionComparer();
Assert.Equal(1, comparer.Compare(left, null));
}
public void ReferenceEqualsRightNull()
{
SemanticVersion version = new SemanticVersion(1, 0, 0);
VersionComparer comparer = new VersionComparer();
Assert.False(comparer.Equals(version, null));
}
public void ReferenceEquals()
{
SemanticVersion version = new SemanticVersion(1, 0, 0);
VersionComparer comparer = new VersionComparer();
Assert.True(comparer.Equals(version, version));
}
public void Compare()
{
SemanticVersion left = new SemanticVersion(1, 0, 0);
SemanticVersion right = new SemanticVersion(1, 0, 0);
VersionComparer comparer = new VersionComparer();
Assert.Equal(0,comparer.Compare(left, right));
}
public void GetHashCodeSame()
{
SemanticVersion left = new SemanticVersion(1, 0, 0, "foo", "bar");
SemanticVersion right = new SemanticVersion(1, 0, 0, "foo", "bar");
VersionComparer comparer = new VersionComparer();
Assert.Equal(comparer.GetHashCode(left), comparer.GetHashCode(right));
}
public void CreateVersionComparer()
{
var array=new VersionComparer[100];
for (int i = 0; i < 100; i++)
{
array[i]=new VersionComparer();
array[i].Compare("a", "a");
}
}
public void ComparePrereleaseRelease()
{
SemanticVersion left = new SemanticVersion(1, 0, 0, "beta");
SemanticVersion right = new SemanticVersion(1, 0, 0);
VersionComparer comparer = new VersionComparer();
// "When major, minor, and patch are equal, a pre-release
// version has lower precedence than a normal version."
Assert.Equal(-1, comparer.Compare(left, right));
}
public void ComparePrereleaseFieldNumber()
{
SemanticVersion left = new SemanticVersion(1, 0, 0, "alpha");
SemanticVersion right = new SemanticVersion(1, 0, 0, "alpha.1");
VersionComparer comparer = new VersionComparer();
// "A larger set of pre-release fields has a higher
// precedence than a smaller set, if all of the preceding
// identifiers are equal."
Assert.Equal(-1, comparer.Compare(left, right));
}
public RulesCheck(string[] patterns, string version, VersionComparer versionComparison)
{
_version = new Version(version);
_patterns = patterns;
if (patterns.Contains("*"))
{
_ex = headers => true;
}
//Otherwise we need to make an expression for each pattern
}
public ActionResult ViewIgChanges(int id)
{
if (!CheckPoint.Instance.GrantViewImplementationGuide(id))
{
throw new AuthorizationException("You do not have access to view this implementation guide's changes.");
}
ImplementationGuide lGuide = this.tdb.ImplementationGuides.Single(ig => ig.Id == id);
ViewChangesModel lModel = new ViewChangesModel();
IGSettingsManager igSettings = new IGSettingsManager(this.tdb, lGuide.Id);
IIGTypePlugin igTypePlugin = lGuide.ImplementationGuideType.GetPlugin();
VersionComparer lComparer = VersionComparer.CreateComparer(tdb, igTypePlugin, igSettings);
lModel.IgName = lGuide.Name;
// Modified templates
foreach (Template lNewTemplate in lGuide.ChildTemplates.Where(t => t.PreviousVersionTemplateId.HasValue))
{
Template lPreviousVersion = this.tdb.Templates.Single(t => t.Id == lNewTemplate.PreviousVersionTemplateId.Value);
ComparisonResult lResult = lComparer.Compare(lPreviousVersion, lNewTemplate);
lModel.TemplateDifferences.Add(
new DifferenceModel(lResult)
{
Id = lNewTemplate.Id,
IsAdded = false,
TemplateName = lNewTemplate.Name,
PreviousTemplateName = string.Format("{0} ({1})", lPreviousVersion.Name, lPreviousVersion.Oid),
PreviousTemplateId = lPreviousVersion.Id,
Difference = lResult,
InlineConstraints = GetInlineConstraintChanges(lResult)
});
}
// Added templates
foreach (Template lNewTemplate in lGuide.ChildTemplates.Where(t => !t.PreviousVersionTemplateId.HasValue))
{
ComparisonResult lResult = lComparer.Compare(new Template(), lNewTemplate);
lModel.TemplateDifferences.Add(
new DifferenceModel(lResult)
{
Id = lNewTemplate.Id,
IsAdded = true,
TemplateName = lNewTemplate.Name
});
}
return(View(lModel));
}
private static IEnumerable <IVsixPackage> _OnlyMostRecentVersions(IEnumerable <IVsixPackage> packages, Logger log)
{
var groups = packages.GroupBy(pkg => pkg.Id);
var versionComparer = new VersionComparer();
foreach (var grp in groups)
{
var package = grp.OrderByDescending(pkg => pkg.Version, versionComparer).First();
if (grp.Count() > 1)
{
log.Info($"Multiple versions of {grp.Key} detected, using version {package.Version}");
}
yield return(package);
}
}
protected override bool GreaterOrEquals(string version, string benchmark)
{
version = version.ToLower().Trim();
benchmark = benchmark.ToLower().Trim();
if (version.Contains("ie") && benchmark.Contains("edge"))
{
return(true);
}
version = version.Replace("ie", string.Empty).Replace("edge", string.Empty).Trim();
benchmark = benchmark.Replace("ie", string.Empty).Replace("edge", string.Empty).Trim();
return(VersionComparer.GreaterEquals(version, benchmark));
}
public static IEnumerable <IVsixPackage> OnlyMostRecentVersions(this IEnumerable <IVsixPackage> packages)
{
var groups = packages.GroupBy(pkg => pkg.Id);
var versionComparer = new VersionComparer();
foreach (var grp in groups)
{
if (grp.Count() > 1)
{
yield return(grp.OrderByDescending(pkg => pkg.Version, versionComparer).First());
}
else
{
yield return(grp.First());
}
}
}
private static bool EqualsOneWay(VersionComparer comparer, string version1, string version2)
{
// Arrange
var a = Version.Parse(version1);
var b = Version.Parse(version2);
Version c = Version.Parse(version1);
Version d = Version.Parse(version2);
// Act
var match = Compare(comparer, version1, version2) == 0;
match &= comparer.Equals(a, b);
match &= comparer.Equals(a, d);
match &= comparer.Equals(c, d);
match &= comparer.Equals(c, b);
return(match);
}
private bool PackageIdentityEquals(PackageIdentity x, PackageIdentity y)
{
if (ReferenceEquals(x, y))
{
return(true);
}
if (ReferenceEquals(x, null) ||
ReferenceEquals(y, null))
{
return(false);
}
var versionComparer = new VersionComparer(VersionComparison.Default);
return(versionComparer.Equals(x.Version, y.Version) &&
StringComparer.OrdinalIgnoreCase.Equals(x.Id, y.Id));
}
private static int CompareOneWay(VersionComparer comparer, string version1, string version2)
{
// Arrange
var a = Version.Parse(version1);
var b = Version.Parse(version2);
var c = Version.Parse(version1);
var d = Version.Parse(version2);
// Act
var results = new List <int>();
results.Add(comparer.Compare(a, b));
results.Add(comparer.Compare(a, d));
results.Add(comparer.Compare(c, b));
results.Add(comparer.Compare(c, d));
// Assert
Assert.True(results.FindAll(x => x == results[0]).Count == results.Count);
return(results[0]);
}
/// <summary>
/// Checks if updates are available for the passed mod.
/// </summary>
/// <param name="modInfo">The ModInfos of the mod to check for updates.</param>
/// <param name="newModInfo">A reference to an empty ModInfo to write the updated ModInfos to.</param>
/// <returns>True if there is an update, otherwise false.</returns>
public bool CheckForUpdates(ModInfo modInfo, ref ModInfo newModInfo)
{
newModInfo = GetModInfo(modInfo.ModURL);
if (string.IsNullOrEmpty(modInfo.Version) && !string.IsNullOrEmpty(newModInfo.Version))
{
return(true);
}
else if (!string.IsNullOrEmpty(modInfo.Version) && !string.IsNullOrEmpty(newModInfo.Version))
{
return(VersionComparer.CompareVersions(modInfo.Version, newModInfo.Version) == VersionComparer.Result.AisSmallerB);
}
else if (string.IsNullOrEmpty(modInfo.CreationDate) && !string.IsNullOrEmpty(newModInfo.CreationDate))
{
return(true);
}
else if (!string.IsNullOrEmpty(modInfo.CreationDate) && !string.IsNullOrEmpty(newModInfo.CreationDate))
{
return(modInfo.CreationDateAsDateTime < newModInfo.CreationDateAsDateTime);
}
return(false);
}
/// <summary>
/// -1 if the client needs to upgrade (supported caps are lower)
/// 0 if the client and feed can work together.
/// 1 if the feed requires an upgrade due to being incompatible with the newer client
/// </summary>
private static int CompareCapabilities(List <FeedCapability> supportedCaps, List <FeedCapability> requiredCaps)
{
foreach (var cap in requiredCaps)
{
var supportedCap = supportedCaps.FirstOrDefault(e => StringComparer.OrdinalIgnoreCase.Equals(e.Name, cap.Name));
if (supportedCap == null)
{
// The feed is newer
return(-1);
}
// Versions must be an exact match
var result = VersionComparer.Compare(supportedCap.Version, cap.Version, VersionComparison.Version);
if (result != 0)
{
return(result);
}
}
return(0);
}
/// <summary>
/// If this IG is a new version of a previous IG, scan the templates for new versions and add them as an appendix
/// </summary>
private void LoadChangesAppendix()
{
List <IGDifferenceViewModel> lDifferences = new List <IGDifferenceViewModel>();
if (this.implementationGuide.PreviousVersionImplementationGuideId.HasValue)
{
VersionComparer lComparer = VersionComparer.CreateComparer(_tdb, this.igTypePlugin, this.igSettings);
var versionedTemplates = this.templates.Where(y => y.OwningImplementationGuideId == this.implementationGuide.Id);
foreach (Template lChildTemplate in versionedTemplates)
{
IGDifferenceViewModel lModel = new IGDifferenceViewModel(lChildTemplate);
if (lChildTemplate.PreviousVersionTemplateId.HasValue)
{
Template lPreviousTemplate = _tdb.Templates.Single(t => t.Id == lChildTemplate.PreviousVersionTemplateId);
lModel.Difference = lComparer.Compare(lPreviousTemplate, lChildTemplate);
lDifferences.Add(lModel);
}
}
this.LoadDifferencesAsAppendix(this.implementationGuide.Name, lDifferences);
}
}
public async Task <PackageVersionResponse> Handle(PackageVersionRequest request)
{
var projectPath = request.ProjectPath;
if (request.ProjectPath.EndsWith(".json"))
{
projectPath = Path.GetDirectoryName(projectPath);
}
if (!string.IsNullOrWhiteSpace(projectPath))
{
if (request.Sources == null)
{
request.Sources = Enumerable.Empty <string>();
}
var token = CancellationToken.None;
var filter = new SearchFilter
{
IncludePrerelease = request.IncludePrerelease
};
var foundVersions = new List <NuGetVersion>();
var repositoryProvider = new OmniSharpSourceRepositoryProvider(projectPath);
var repos = repositoryProvider.GetRepositories().ToArray();
if (request.Sources.Any())
{
// Reduce to just the sources we requested
repos = repos.Join(request.Sources, x => x.PackageSource.Source, x => x, (x, y) => x).ToArray();
}
foreach (var repo in repos)
{
// TODO: Swap when bug is fixed
// https://github.com/NuGet/NuGet3/pull/90
/*
* var resource = await repo.GetResourceAsync<FindPackageByIdResource>();
* if (resource != null)
* {
* resource.Logger = NullLogger.Instance;
* resource.NoCache = true;
* foundVersions.AddRange(await resource.GetAllVersionsAsync(request.Id, token));
* }*/
var resource = await repo.GetResourceAsync <SimpleSearchResource>();
if (resource != null)
{
var result = await resource.Search(request.Id, filter, 0, 50, token);
var package = result.FirstOrDefault(metadata => metadata.Identity.Id == request.Id);
if (package != null)
{
foundVersions.AddRange(package.AllVersions);
}
}
}
var comparer = new VersionComparer();
var versions = Enumerable.Distinct <NuGetVersion>(foundVersions, comparer)
.OrderByDescending(version => version, comparer)
.Select(version => version.ToNormalizedString());
return(new PackageVersionResponse()
{
Versions = versions
});
}
return(new PackageVersionResponse());
}
public void VersionComparerTest1()
{
Template parentTemplate = this.mockRepo.GenerateTemplate("3.2.1.4.3", this.documentType, "Parent Template", this.ig);
Template aTemplate = this.mockRepo.GenerateTemplate("1.2.3.4", this.documentType, "Test Template", this.ig, description: "Test Description 1");
aTemplate.IsOpen = false;
this.mockRepo.GenerateConstraint(aTemplate, null, null, "id", "SHALL", "1..1", number: 1);
this.mockRepo.GenerateConstraint(aTemplate, null, null, "effectiveTime", "SHALL", "1..1", number: 2);
this.mockRepo.GenerateConstraint(aTemplate, null, null, "entryRelationship", "SHALL", "1..1", number: 3);
Template bTemplate = this.mockRepo.GenerateTemplate("4.3.2.1", this.documentType, "New Test Template", this.ig, description: "Test Description 2", impliedTemplate: parentTemplate);
bTemplate.IsOpen = true;
this.mockRepo.GenerateConstraint(bTemplate, null, null, "id", "SHALL", "1..*", number: 1);
this.mockRepo.GenerateConstraint(bTemplate, null, null, "entryRelationship", "SHALL", "1..1", number: 3);
this.mockRepo.GenerateConstraint(bTemplate, null, null, "author", "SHALL", "1..1", number: 4);
VersionComparer comparer = VersionComparer.CreateComparer(mockRepo);
ComparisonResult compared = comparer.Compare(aTemplate, bTemplate);
// Test template changes
Assert.AreEqual(5, compared.ChangedFields.Count, "Expected to find 5 template fields changed");
var changedName = compared.ChangedFields.Single(y => y.Name == "Name");
Assert.AreEqual(aTemplate.Name, changedName.Old);
Assert.AreEqual(bTemplate.Name, changedName.New);
var changedDescription = compared.ChangedFields.Single(y => y.Name == "Description");
Assert.AreEqual(aTemplate.Description, changedDescription.Old);
Assert.AreEqual(bTemplate.Description, changedDescription.New);
var changedOid = compared.ChangedFields.Single(y => y.Name == "Oid");
Assert.AreEqual(aTemplate.Oid, changedOid.Old);
Assert.AreEqual(bTemplate.Oid, changedOid.New);
var changedImpliedTemplate = compared.ChangedFields.Single(y => y.Name == "Implied Template");
Assert.AreEqual("", changedImpliedTemplate.Old);
Assert.AreEqual("Parent Template (3.2.1.4.3)", changedImpliedTemplate.New);
var changedIsOpen = compared.ChangedFields.Single(y => y.Name == "Open/Closed");
Assert.AreEqual("Closed", changedIsOpen.Old);
Assert.AreEqual("Open", changedIsOpen.New);
// Test constraint changes
Assert.AreEqual(4, compared.ChangedConstraints.Count, "Expected to find 3 changed constraints");
var removedConstraint = compared.ChangedConstraints.Single(y => y.Type == CompareStatuses.Removed);
Assert.AreEqual("1-2", removedConstraint.Number);
Assert.AreEqual(0, removedConstraint.ChangedFields.Count);
Assert.IsFalse(string.IsNullOrEmpty(removedConstraint.OldNarrative));
var addedConstraint = compared.ChangedConstraints.Single(y => y.Type == CompareStatuses.Added);
Assert.AreEqual("1-4", addedConstraint.Number);
Assert.AreEqual(0, addedConstraint.ChangedFields.Count);
Assert.IsFalse(string.IsNullOrEmpty(addedConstraint.NewNarrative));
var changedConstraint = compared.ChangedConstraints.Single(y => y.Type == CompareStatuses.Modified);
Assert.AreEqual("1-1", changedConstraint.Number);
Assert.IsFalse(string.IsNullOrEmpty(changedConstraint.NewNarrative));
Assert.IsFalse(string.IsNullOrEmpty(changedConstraint.OldNarrative));
Assert.AreNotEqual(changedConstraint.OldNarrative, changedConstraint.NewNarrative);
Assert.AreEqual(1, changedConstraint.ChangedFields.Count);
Assert.IsNotNull(changedConstraint.ChangedFields.SingleOrDefault(y => y.Name == "Cardinality"));
var unchangedConstraint = compared.ChangedConstraints.Single(y => y.Type == CompareStatuses.Unchanged);
Assert.AreEqual("1-3", unchangedConstraint.Number);
}
// A versions file is of the form https://raw.githubusercontent.com/dotnet/versions/master/build-info/dotnet/corefx/release/1.0.0/LKG_Packages.txt
private Dictionary <string, PackageItem> GatherPackageInformationFromVersionsFile(Uri uri, VersionComparer comparer = null)
{
Dictionary <string, PackageItem> packageItems = new Dictionary <string, PackageItem>();
try
{
using (var streamReader = new StreamReader(GetStream(uri).Result))
{
while (!streamReader.EndOfStream)
{
string line = streamReader.ReadLine();
if (!string.IsNullOrWhiteSpace(line))
{
string[] packageVersionTokens = line.Split(' ');
PackageItem packageItem = CreatePackageItem(packageVersionTokens[0], packageVersionTokens[1]);
AddPackageItemToDictionary(packageItems, packageItem);
}
}
}
}
catch (AggregateException)
{
Log.LogError("Error: Unable to open '{0}', either the file does not exist locally or there is a network issue accessing that URI.", uri.ToString());
throw;
}
return(packageItems);
}
public void CompareBothNull()
{
VersionComparer comparer = new VersionComparer();
Assert.Equal(0, comparer.Compare(null, null));
}
public async Task VersionParseSucceeds(string versionString)
{
System.Collections.Generic.List <string>?result = VersionComparer.Parse(versionString);
Assert.AreEqual(string.Join("", result), versionString);
}
public void Compare_min()
{
//arrange
string stEtalon = "15.2.9";
string stMajorMin = "14.2.9";
string stMajorMax = "16.2.9";
string stMinorMin = "15.1.9";
string stMinorMax = "16.1.9";
string stBuildMin = "15.2.8";
string stBuildMax = "15.2.10";
VersionComparer comp = new VersionComparer();
//act
int majMinRes = comp.Compare(stEtalon, stMajorMin);
int majMaxRes = comp.Compare(stEtalon, stMajorMax);
int minMinRes = comp.Compare(stEtalon, stMinorMin);
int mimMaxRes = comp.Compare(stEtalon, stMinorMax);
int buildMinRes = comp.Compare(stEtalon, stBuildMin);
int buildMaxRes = comp.Compare(stBuildMin, stBuildMax);
//assert
Assert.AreEqual(-1, majMinRes);
Assert.AreEqual(1, majMaxRes);
Assert.AreEqual(-1, minMinRes);
Assert.AreEqual(1, mimMaxRes);
Assert.AreEqual(-1, buildMinRes);
Assert.AreEqual(1, buildMaxRes);
}
public void CompareBothNull()
{
VersionComparer comparer = new VersionComparer();
Assert.Equal(0, comparer.Compare(null, null));
}
/// <summary>
/// Получение детальной информации об обновлениях шаблона из xml
/// </summary>
/// <param name="prevVersion">Текущая версия</param>
/// <param name="updatesInFolder">Список обновлений, которые находятся в папке</param>
/// <returns>Перечисление названий обновлений, которые необходимо поставить, с учётом текущей версии</returns>
private IEnumerable <string> GetInfoListUpdates(string prevVersion, IEnumerable <string> updatesInFolder)
{
_log.Trace("Get updates information from xml");
var templateInfo = new TemplateDetailInformation();
templateInfo.Updates = _templateDetail.Updates;
var currentVersion = prevVersion;
var result = new List <string>();
try
{
while (true)
{
// получаем версии обновлений, для которых используемая версия отличается от текущей (из xml)
var updateVersions = templateInfo.Updates.Where(upd =>
upd.ApplyVersions.Any(version => VersionComparer.CompareSt(version, currentVersion) == 0)).
Select(upd => upd.UpdateVersion);
_log.Info("Updates version {0}", updateVersions);
// далее из полученного выбираем ту версию, которая отличается от версий обновлений в папке (самую последнюю)
var updVersion = updateVersions.Where(version => updatesInFolder.Any(versionInFile =>
VersionComparer.CompareSt(version, versionInFile) == 0)).OrderByDescending(version =>
version, new VersionComparer()).FirstOrDefault();
_log.Info("updVersion {0}", updVersion);
if (!string.IsNullOrEmpty(updVersion))
{
currentVersion = updVersion;
// и если всё хорошо, то добавляем её к списку требуемых к загрузке обновлений
result.Add(updVersion);
}
else
{
break;
}
}
_log.Trace("Getting updates information from xml has been completed");
}
catch (Exception ex)
{
_log.Error("Error during getting detail information from xml file: {0}", ex.Message);
}
return(result);
}
// A versions file is of the form https://github.com/dotnet/versions/blob/master/build-info/dotnet/corefx/master/Latest_Packages.txt
private Dictionary <string, PackageItem> GatherPackageInformationFromVersionsFile(string versionsFile, VersionComparer comparer = null)
{
Dictionary <string, PackageItem> packageItems = new Dictionary <string, PackageItem>();
if (!File.Exists(versionsFile))
{
Log.LogError("Specified versions file ({0}) does not exist.", versionsFile);
}
var lines = File.ReadAllLines(versionsFile);
foreach (string line in lines)
{
if (!string.IsNullOrWhiteSpace(line))
{
string [] packageVersionTokens = line.Split(' ');
PackageItem packageItem = CreatePackageItem(packageVersionTokens[0], packageVersionTokens[1]);
AddPackageItemToDictionary(packageItems, packageItem);
}
}
return(packageItems);
}
/// <summary>
/// Checks if updates are available for the passed mod.
/// </summary>
/// <param name="modInfo">The ModInfos of the mod to check for updates.</param>
/// <param name="newModInfo">A reference to an empty ModInfo to write the updated ModInfos to.</param>
/// <returns>True if there is an update, otherwise false.</returns>
public bool CheckForUpdates(ModInfo modInfo, ref ModInfo newModInfo)
{
newModInfo = GetModInfo(modInfo.ModURL);
return(VersionComparer.CompareVersions(modInfo.Version, newModInfo.Version) == VersionComparer.Result.AisSmallerB);
}
protected override bool AppliesToVersion(Game game)
=> VersionComparer.GreaterThan(GameVersion, ApplicationVersion.FromString("e1.0.0"));
protected override bool GreaterOrEquals(string version, string benchmark)
{
return(VersionComparer.GreaterEquals(version, benchmark));
}
private static bool Equals(VersionComparer comparer, string version1, string version2)
{
return(EqualsOneWay(comparer, version1, version2) && EqualsOneWay(comparer, version2, version1));
}
public int Compare(Version version, Version otherVersion) => VersionComparer.Compare(version, otherVersion);
private int CompareVersion(NuGetVersion v1, NuGetVersion v2) => VersionComparer.Compare(v1, v2, VersionComparison.Version);
public ViewDataModel GetExportData(int implementationGuideId, int?fileId, int[] templateIds, bool inferred)
{
ImplementationGuide ig = this.tdb.ImplementationGuides.Single(y => y.Id == implementationGuideId);
ViewDataModel model = null;
SimpleSchema schema = ig.ImplementationGuideType.GetSimpleSchema();
if (fileId != null)
{
var file = ig.Files.Single(y => y.Id == fileId);
var fileData = file.GetLatestData();
if (file.ContentType != "DataSnapshot")
{
throw new Exception("File specified is not a data snapshot!");
}
string fileDataContent = System.Text.Encoding.UTF8.GetString(fileData.Data);
model = JsonConvert.DeserializeObject <ViewDataModel>(fileDataContent);
model.ImplementationGuideFileId = fileId;
}
else
{
Log.For(this).Trace("Generating HTML export for " + implementationGuideId);
IGSettingsManager igSettings = new IGSettingsManager(this.tdb, implementationGuideId);
var igTypePlugin = ig.ImplementationGuideType.GetPlugin();
var firstTemplateType = ig.ImplementationGuideType.TemplateTypes.OrderBy(y => y.OutputOrder).FirstOrDefault();
var valueSets = ig.GetValueSets(this.tdb);
var parentTemplateIds = templateIds != null?templateIds.ToList() : null;
var templates =
ig.GetQueryableRecursiveTemplates(this.tdb, parentTemplateIds, inferred)
.IncludeDetails(true, true, true)
.ToList();
var constraints = templates.SelectMany(y => y.ChildConstraints);
var previousVersionIds = templates.Where(y => y.PreviousVersionTemplateId != null).Select(y => y.PreviousVersionTemplateId.Value).ToList();
var previousVersions = this.tdb.Templates.Where(y => previousVersionIds.Contains(y.Id))
.IncludeDetails(true, true, true)
.ToList();
var containedTemplates = (from st in templates
join vtr in this.tdb.ViewTemplateRelationships.AsNoTracking() on st.Id equals vtr.ParentTemplateId
join t in this.tdb.Templates.AsNoTracking() on vtr.ChildTemplateId equals t.Id
select new
{
Relationship = vtr,
Template = t
}).ToList();
var containedByTemplates = (from st in templates
join vtr in this.tdb.ViewTemplateRelationships.AsNoTracking() on st.Id equals vtr.ChildTemplateId
join t in this.tdb.Templates.AsNoTracking() on vtr.ParentTemplateId equals t.Id
select new
{
Relationship = vtr,
Template = t
}).ToList();
this.constraintReferences = (from c in constraints
join tcr in this.tdb.TemplateConstraintReferences.AsNoTracking() on c.Id equals tcr.TemplateConstraintId
join t in this.tdb.Templates.AsNoTracking() on tcr.ReferenceIdentifier equals t.Oid
join ig1 in this.tdb.ImplementationGuides.AsNoTracking() on t.OwningImplementationGuideId equals ig1.Id
where tcr.ReferenceType == ConstraintReferenceTypes.Template
select new ExportConstraintReference()
{
Bookmark = t.Bookmark,
Identifier = t.Oid,
Name = t.Name,
TemplateConstraintId = tcr.TemplateConstraintId,
IncludedInIG = templates.Contains(t),
ImplementationGuide =
!string.IsNullOrEmpty(ig1.DisplayName) ?
ig1.DisplayName :
ig1.Name + " V" + ig1.Version.ToString(),
PublishDate = ig1.PublishDate
}).ToList();
model = new ViewDataModel()
{
ImplementationGuideId = implementationGuideId,
ImplementationGuideName = !string.IsNullOrEmpty(ig.DisplayName) ? ig.DisplayName : ig.NameWithVersion,
ImplementationGuideFileId = fileId,
Status = ig.PublishStatus.Status,
PublishDate = ig.PublishDate != null?ig.PublishDate.Value.ToShortDateString() : null,
Volume1Html = igSettings.GetSetting(IGSettingsManager.SettingProperty.Volume1Html)
};
model.ImplementationGuideDescription = ig.WebDescription;
model.ImplementationGuideDisplayName = !string.IsNullOrEmpty(ig.WebDisplayName) ? ig.WebDisplayName : model.ImplementationGuideName;
Log.For(this).Trace("Including Volume 1 sections");
// Create the section models
var sections = ig.Sections.OrderBy(y => y.Order).ToList();
model.Volume1Sections = (from igs in sections
select new ViewDataModel.Section()
{
Heading = igs.Heading,
Content = igs.Content.MarkdownToHtml(),
Level = igs.Level
}).ToList();
Log.For(this).Trace("Including FHIR resources attached to IG");
// Include any FHIR Resource Instance attachments with the IG
foreach (var fhirResourceInstanceFile in ig.Files.Where(y => y.ContentType == "FHIRResourceInstance"))
{
var fileData = fhirResourceInstanceFile.GetLatestData();
string fileContent = System.Text.Encoding.UTF8.GetString(fileData.Data);
ViewDataModel.FHIRResource newFhirResource = new ViewDataModel.FHIRResource()
{
Name = fhirResourceInstanceFile.FileName,
JsonContent = igTypePlugin.GetFHIRResourceInstanceJson(fileContent),
XmlContent = igTypePlugin.GetFHIRResourceInstanceXml(fileContent)
};
if (!string.IsNullOrEmpty(newFhirResource.JsonContent) || !string.IsNullOrEmpty(newFhirResource.XmlContent))
{
model.FHIRResources.Add(newFhirResource);
}
}
Log.For(this).Trace("Including value sets");
foreach (var valueSet in valueSets)
{
var newValueSetModel = new ViewDataModel.ValueSet()
{
Identifier = valueSet.ValueSet.GetIdentifier(igTypePlugin),
Name = valueSet.ValueSet.Name,
Source = valueSet.ValueSet.Source,
Description = valueSet.ValueSet.Description,
BindingDate = valueSet.BindingDate != null?valueSet.BindingDate.Value.ToShortDateString() : null
};
var members = valueSet.ValueSet.GetActiveMembers(valueSet.BindingDate);
newValueSetModel.Members = (from vsm in members
join cs in this.tdb.CodeSystems on vsm.CodeSystemId equals cs.Id
select new ViewDataModel.ValueSetMember()
{
Code = vsm.Code,
DisplayName = vsm.DisplayName,
CodeSystemIdentifier = cs.Oid,
CodeSystemName = cs.Name
}).ToList();
model.ValueSets.Add(newValueSetModel);
// Add code systems used by this value set to the IG
var codeSystems = (from vsm in members
join cs in this.tdb.CodeSystems on vsm.CodeSystemId equals cs.Id
select new ViewDataModel.CodeSystem()
{
Identifier = cs.Oid,
Name = cs.Name
});
model.CodeSystems.AddRange(codeSystems);
}
Log.For(this).Trace("Including templates");
foreach (var template in templates)
{
var templateId = template.Id;
var templateSchema = schema.GetSchemaFromContext(template.PrimaryContextType);
var previousVersion = previousVersions.SingleOrDefault(y => y.Id == template.PreviousVersionTemplateId);
var newTemplateModel = new ViewDataModel.Template()
{
Identifier = template.Oid,
Bookmark = template.Bookmark,
ContextType = template.PrimaryContextType,
Context = template.PrimaryContext,
Name = template.Name,
ImpliedTemplate = template.ImpliedTemplate != null ? new ViewDataModel.TemplateReference(template.ImpliedTemplate) : null,
Description = template.Description.MarkdownToHtml(),
Extensibility = template.IsOpen ? "Open" : "Closed",
TemplateTypeId = template.TemplateTypeId
};
// Load Template Changes
if (previousVersion != null)
{
var comparer = VersionComparer.CreateComparer(this.tdb, igTypePlugin, igSettings);
var result = comparer.Compare(previousVersion, template);
newTemplateModel.Changes = new DifferenceModel(result)
{
Id = template.Id,
TemplateName = template.Name,
PreviousTemplateName = string.Format("{0} ({1})", previousVersion.Name, previousVersion.Oid),
PreviousTemplateId = previousVersion.Id
};
}
// Code systems used in this template to the IG
var codeSystems = (from tc in template.ChildConstraints
where tc.CodeSystem != null
select new ViewDataModel.CodeSystem()
{
Identifier = tc.CodeSystem.Oid,
Name = tc.CodeSystem.Name
});
model.CodeSystems.AddRange(codeSystems);
// Samples
newTemplateModel.Samples = (from ts in template.TemplateSamples
select new ViewDataModel.Sample()
{
Id = ts.Id,
Name = ts.Name,
SampleText = ts.XmlSample
}).ToList();
// Contained templates
var thisContainedTemplates = containedTemplates
.Where(y => y.Relationship.ParentTemplateId == templateId)
.GroupBy(y => y.Template)
.Select(y => y.First());
newTemplateModel.ContainedTemplates = thisContainedTemplates.Select(y => new ViewDataModel.TemplateReference(y.Template)).ToList();
// Contained by templates
var thisContainedByTemplates = containedByTemplates
.Where(y => y.Relationship.ChildTemplateId == templateId)
.GroupBy(y => y.Template)
.Select(y => y.First());
newTemplateModel.ContainedByTemplates = thisContainedByTemplates.Select(y => new ViewDataModel.TemplateReference(y.Template)).ToList();
// Implying templates
var implyingTemplates = (from t in templates
where t.ImpliedTemplateId == template.Id
select t).Distinct().ToList();
newTemplateModel.ImplyingTemplates = implyingTemplates.Select(y => new ViewDataModel.TemplateReference(y)).ToList();
model.Templates.Add(newTemplateModel);
// Create the constraint models (hierarchically)
var parentConstraints = template.ChildConstraints.Where(y => y.ParentConstraintId == null);
CreateConstraints(igSettings, igTypePlugin, parentConstraints, newTemplateModel.Constraints, templateSchema);
}
Log.For(this).Trace("Including template types");
// Create models for template types in the IG
model.TemplateTypes = (from igt in igSettings.TemplateTypes
join tt in this.tdb.TemplateTypes.AsNoTracking() on igt.TemplateTypeId equals tt.Id
where model.Templates.Exists(y => y.TemplateTypeId == tt.Id)
select new ViewDataModel.TemplateType()
{
TemplateTypeId = tt.Id,
Name = igt.Name,
ContextType = tt.RootContextType,
Description = igt.DetailsText
}).ToList();
Log.For(this).Trace("Including code systems");
model.CodeSystems = model.CodeSystems.Distinct().ToList();
}
this.FixImagePaths(model);
Log.For(this).Trace("Done generating HTML export for " + implementationGuideId);
return(model);
}
