private void UpdateCardinalities(IGSettingsManager igSettings, ImportImplementationGuide importImplementationGuide)
{
foreach (var importCardinality in importImplementationGuide.CardinalityDisplay)
{
switch (importCardinality.cardinality)
{
case Shared.ImportExport.Model.CardinalityTypes.Zero:
igSettings.SaveSetting(IGSettingsManager.SettingProperty.CardinalityZero, importCardinality.display);
break;
case Shared.ImportExport.Model.CardinalityTypes.ZeroOrOne:
igSettings.SaveSetting(IGSettingsManager.SettingProperty.CardinalityZeroToOne, importCardinality.display);
break;
case Shared.ImportExport.Model.CardinalityTypes.ZeroToMany:
igSettings.SaveSetting(IGSettingsManager.SettingProperty.CardinalityZeroOrMore, importCardinality.display);
break;
case Shared.ImportExport.Model.CardinalityTypes.One:
igSettings.SaveSetting(IGSettingsManager.SettingProperty.CardinalityOneToOne, importCardinality.display);
break;
case Shared.ImportExport.Model.CardinalityTypes.OneToMany:
igSettings.SaveSetting(IGSettingsManager.SettingProperty.CardinalityAtLeastOne, importCardinality.display);
break;
default:
throw new ArgumentException("Unexpected cardinality value " + importCardinality.cardinality);
}
}
}
private void UpdateCustomSchematron(ImplementationGuide implementationGuide, ImportImplementationGuide importImplementationGuide)
{
var allCustomSchematrons = implementationGuide.SchematronPatterns.ToList();
// Remove all first
foreach (var customSchematron in allCustomSchematrons)
{
this.tdb.ImplementationGuideSchematronPatterns.DeleteObject(customSchematron);
}
// Add all in import as new
foreach (var importCustomSchematron in importImplementationGuide.CustomSchematron)
{
var foundSchematronPattern = new ImplementationGuideSchematronPattern();
foundSchematronPattern.PatternId = importCustomSchematron.patternId;
implementationGuide.SchematronPatterns.Add(foundSchematronPattern);
if (foundSchematronPattern.Phase != importCustomSchematron.phase)
{
foundSchematronPattern.Phase = importCustomSchematron.phase;
}
if (foundSchematronPattern.PatternContent != importCustomSchematron.Rule)
{
foundSchematronPattern.PatternContent = importCustomSchematron.Rule;
}
}
}
private void UpdateTemplateTypes(ImplementationGuide implementationGuide, ImportImplementationGuide importImplementationGuide)
{
foreach (var importTemplateType in importImplementationGuide.CustomTemplateType)
{
var foundTemplateType = implementationGuide.ImplementationGuideType.TemplateTypes.SingleOrDefault(y => y.Name.ToLower() == importTemplateType.templateTypeName.ToLower());
if (foundTemplateType == null)
{
throw new Exception("Could not find template type " + importTemplateType.templateTypeName + " associated with implementation guide type");
}
var foundIgTemplateType = implementationGuide.TemplateTypes.SingleOrDefault(y => y.TemplateTypeId == foundTemplateType.Id);
if (foundIgTemplateType == null)
{
foundIgTemplateType = new ImplementationGuideTemplateType();
foundIgTemplateType.TemplateType = foundTemplateType;
foundIgTemplateType.TemplateTypeId = foundTemplateType.Id;
foundIgTemplateType.ImplementationGuide = implementationGuide;
implementationGuide.TemplateTypes.Add(foundIgTemplateType);
}
if (foundIgTemplateType.Name != importTemplateType.CustomName)
{
foundIgTemplateType.Name = importTemplateType.CustomName;
}
if (foundIgTemplateType.DetailsText != importTemplateType.Description)
{
foundIgTemplateType.DetailsText = importTemplateType.Description;
}
}
}
private void UpdateFiles(ImplementationGuide implementationGuide, ImportImplementationGuide importImplementationGuide)
{
var currentUser = CheckPoint.Instance.GetUser(this.tdb);
string currentUserName = currentUser != null?
string.Format("{0} {1} ({2})", currentUser.FirstName, currentUser.LastName, currentUser.Email) :
"Unknown user";
foreach (var importFile in importImplementationGuide.File)
{
if (string.IsNullOrEmpty(importFile.name))
{
continue;
}
var foundFile = implementationGuide.Files.SingleOrDefault(y => y.FileName.ToLower() == importFile.name.ToLower());
if (foundFile == null)
{
foundFile = new ImplementationGuideFile();
foundFile.FileName = importFile.name;
foundFile.ImplementationGuide = implementationGuide;
this.tdb.ImplementationGuideFiles.Add(foundFile);
}
var latestData = foundFile.Versions.Count > 0 ? foundFile.GetLatestData() : null;
byte[] content = Convert.FromBase64String(importFile.Content);
if (latestData == null || latestData.Data.Length != content.Length)
{
latestData = new ImplementationGuideFileData();
latestData.ImplementationGuideFile = foundFile;
latestData.Data = content;
latestData.UpdatedDate = DateTime.Now;
latestData.UpdatedBy = currentUserName;
this.tdb.ImplementationGuideFileDatas.Add(latestData);
}
// Update properties of the file
foundFile.MimeType = importFile.mimeType;
foundFile.ContentType = importFile.type.ToString();
foundFile.Description = importFile.Description;
}
}
private PublishStatus GetImportStatus(ImportImplementationGuide importIg)
{
switch (importIg.status)
{
case Shared.ImportExport.Model.ImplementationGuideStatus.Ballot:
return(PublishStatus.GetBallotStatus(this.tdb));
case Shared.ImportExport.Model.ImplementationGuideStatus.Published:
return(PublishStatus.GetPublishedStatus(this.tdb));
case Shared.ImportExport.Model.ImplementationGuideStatus.Deprecated:
return(PublishStatus.GetDeprecatedStatus(this.tdb));
case Shared.ImportExport.Model.ImplementationGuideStatus.Retired:
return(PublishStatus.GetRetiredStatus(this.tdb));
default:
return(PublishStatus.GetDraftStatus(this.tdb));
}
}
private void UpdateVolume1(ImplementationGuide implementationGuide, IGSettingsManager igSettings, ImportImplementationGuide importImplementationGuide)
{
if (importImplementationGuide.Volume1 == null)
{
igSettings.SaveSetting(IGSettingsManager.SettingProperty.Volume1Html, string.Empty);
this.RemoveVolume1Sections(implementationGuide);
return;
}
if (importImplementationGuide.Volume1.Items.Count == 1 && importImplementationGuide.Volume1.Items.First() is string)
{
this.RemoveVolume1Sections(implementationGuide);
igSettings.SaveSetting(IGSettingsManager.SettingProperty.Volume1Html, importImplementationGuide.Volume1.Items.First() as string);
}
else if (importImplementationGuide.Volume1.Items.Count > 0)
{
igSettings.SaveSetting(IGSettingsManager.SettingProperty.Volume1Html, string.Empty);
foreach (ImportImplementationGuideSection importSection in importImplementationGuide.Volume1.Items)
{
if (importSection.Heading == null)
{
throw new ArgumentException("All implementation guide sections must have a heading");
}
ImplementationGuideSection newSection = new ImplementationGuideSection()
{
Heading = importSection.Heading.Title,
Level = importSection.Heading.Level,
Order = implementationGuide.Sections.Count + 1
};
implementationGuide.Sections.Add(newSection);
}
}
}
public ImplementationGuide Import(ImportImplementationGuide importImplementationGuide)
{
var implementationGuide = FindImplementationGuide(importImplementationGuide.name, importImplementationGuide.version);
ImplementationGuide foundPreviousVersionIg = null;
IGSettingsManager igSettings = null;
var igType = this.tdb.ImplementationGuideTypes.SingleOrDefault(y => y.Name.ToLower() == importImplementationGuide.type.ToLower());
this.Errors = new List <string>();
if (igType == null)
{
this.Errors.Add("Implementation guide type \"" + importImplementationGuide.type + "\" is not found");
return(null);
}
// Make sure IG's previous version is set
// May not have an "id" for the previous version, so using the entity model to ensure the reference saves
if (importImplementationGuide.PreviousVersion != null && !string.IsNullOrEmpty(importImplementationGuide.PreviousVersion.name) && importImplementationGuide.PreviousVersion.number > 0)
{
foundPreviousVersionIg = FindImplementationGuide(importImplementationGuide.PreviousVersion.name, importImplementationGuide.PreviousVersion.number);
if (foundPreviousVersionIg != null && !foundPreviousVersionIg.PreviousVersion.Contains(implementationGuide))
{
foundPreviousVersionIg.PreviousVersion.Add(implementationGuide);
}
}
if (implementationGuide == null && foundPreviousVersionIg == null && this.tdb.ImplementationGuides.Count(y => y.Name.ToLower() == importImplementationGuide.name.ToLower()) > 0)
{
this.Errors.Add("Implementation guide with the same name already exists, and this is not a new version of that implementation guide.");
return(null);
}
if (implementationGuide == null)
{
implementationGuide = new ImplementationGuide();
implementationGuide.ImplementationGuideType = igType;
implementationGuide.ImplementationGuideTypeId = igType.Id;
this.tdb.ImplementationGuides.AddObject(implementationGuide);
igSettings = new IGSettingsManager(this.tdb);
// Add default template types to new implementation guide
foreach (var templateType in igType.TemplateTypes)
{
var igTemplateType = new ImplementationGuideTemplateType()
{
TemplateType = templateType,
Name = templateType.Name
};
implementationGuide.TemplateTypes.Add(igTemplateType);
}
}
else
{
igSettings = new IGSettingsManager(this.tdb, implementationGuide.Id);
}
// Set changed/new properties of implementation guide
this.UpdateProperties(implementationGuide, igType, importImplementationGuide);
// Update cardinalities
this.UpdateCardinalities(igSettings, importImplementationGuide);
// Update custom template type names
this.UpdateTemplateTypes(implementationGuide, importImplementationGuide);
// Update custom schematron rules
this.UpdateCustomSchematron(implementationGuide, importImplementationGuide);
// Update volume1 HTML and/or Sections
this.UpdateVolume1(implementationGuide, igSettings, importImplementationGuide);
// Update categories
this.UpdateCategories(implementationGuide, igSettings, importImplementationGuide);
if (foundPreviousVersionIg != null && foundPreviousVersionIg.PublishStatus != PublishStatus.GetPublishedStatus(this.tdb))
{
this.Errors.Add("Previous version of implementation guide is not published, and cannot hav a new version associated with it");
return(null);
}
var existingNextVersion = foundPreviousVersionIg != null?
this.tdb.ImplementationGuides.SingleOrDefault(y => y.PreviousVersionImplementationGuideId == foundPreviousVersionIg.Id) :
null;
// Validate versioning of the implementation guide
if (foundPreviousVersionIg == null && implementationGuide.Version != 1)
{
this.Errors.Add("Implementation guide cannot have a version greater than one when no previous version is specified");
return(null);
}
if (foundPreviousVersionIg != null && existingNextVersion != null && existingNextVersion != implementationGuide)
{
this.Errors.Add("Previous version of implementation guide already has a new version created for it");
return(null);
}
// If the object is changed, make sure the user has permissions to the implementation guide
if (this.dataSource != null)
{
var igState = this.dataSource.ObjectStateManager.GetObjectStateEntry(implementationGuide);
if (igState.State == System.Data.Entity.EntityState.Modified && !CheckPoint.Instance.GrantEditImplementationGuide(implementationGuide.Id) && !CheckPoint.Instance.IsDataAdmin)
{
this.Errors.Add("You do not have permission to modify implementation guide \"" + implementationGuide.Name + "\" version " + implementationGuide.Version);
return(null);
}
}
return(implementationGuide);
}
private void UpdateCategories(ImplementationGuide implementationGuide, IGSettingsManager igSettings, ImportImplementationGuide importImplementationGuide)
{
var currentCategories = igSettings.GetSetting(IGSettingsManager.SettingProperty.Categories);
if (importImplementationGuide.Category == null || importImplementationGuide.Category.Count == 0)
{
if (!string.IsNullOrEmpty(currentCategories))
{
igSettings.SaveSetting(IGSettingsManager.SettingProperty.Categories, string.Empty);
}
return;
}
var categories = importImplementationGuide.Category.Select(y => y.name.Replace(',', '-'));
var categoriesString = String.Join(",", categories);
if (currentCategories != categoriesString)
{
igSettings.SaveSetting(IGSettingsManager.SettingProperty.Categories, categoriesString);
}
}
private void UpdateProperties(ImplementationGuide implementationGuide, ImplementationGuideType igType, ImportImplementationGuide importImplementationGuide)
{
var importIgStatus = GetImportStatus(importImplementationGuide);
if (implementationGuide.Organization == null)
{
implementationGuide.Organization = CheckPoint.Instance.GetUser(this.tdb).Organization;
}
if (implementationGuide.Name != importImplementationGuide.name)
{
implementationGuide.Name = importImplementationGuide.name;
}
if (implementationGuide.ImplementationGuideType != igType)
{
implementationGuide.ImplementationGuideType = igType;
}
if (implementationGuide.Version != importImplementationGuide.version)
{
implementationGuide.Version = importImplementationGuide.version;
}
if (implementationGuide.DisplayName != importImplementationGuide.displayName)
{
implementationGuide.DisplayName = importImplementationGuide.displayName;
}
if (implementationGuide.WebReadmeOverview != importImplementationGuide.WebReadmeOverview)
{
implementationGuide.WebReadmeOverview = importImplementationGuide.WebReadmeOverview;
}
if (implementationGuide.WebDisplayName != importImplementationGuide.webDisplayName)
{
implementationGuide.WebDisplayName = importImplementationGuide.webDisplayName;
}
if (implementationGuide.WebDescription != importImplementationGuide.WebDescription)
{
implementationGuide.WebDescription = importImplementationGuide.WebDescription;
}
if (implementationGuide.PublishStatus != importIgStatus)
{
implementationGuide.PublishStatus = importIgStatus;
}
}
public static ExportImplementationGuide Export(this ImplementationGuide ig, IObjectRepository tdb, IGSettingsManager igSettings)
{
ExportImplementationGuide exportIg = new ExportImplementationGuide()
{
name = ig.Name,
type = ig.ImplementationGuideType.Name,
version = ig.Version != null ? ig.Version.Value : 1,
status = ig.GetExportStatus(),
displayName = ig.DisplayName,
webDisplayName = ig.WebDisplayName,
WebDescription = ig.WebDescription,
WebReadmeOverview = ig.WebReadmeOverview,
Volume1 = null,
PreviousVersion = null // Needed so that the generated model doesn't produce an empty <PreviousVersion> element when serialized
};
if (ig.PreviousVersionImplementationGuideId != null)
{
var previousVersionIg = tdb.ImplementationGuides.Single(y => y.Id == ig.PreviousVersionImplementationGuideId);
exportIg.PreviousVersion = new Shared.ImportExport.Model.TrifoliaImplementationGuidePreviousVersion()
{
name = previousVersionIg.Name,
number = previousVersionIg.Version != null ? previousVersionIg.Version.Value : 1
};
}
exportIg.CardinalityDisplay.Add(new Shared.ImportExport.Model.TrifoliaImplementationGuideCardinalityDisplay()
{
cardinality = Shared.ImportExport.Model.CardinalityTypes.Zero,
display = igSettings.GetSetting(IGSettingsManager.SettingProperty.CardinalityZero)
});
exportIg.CardinalityDisplay.Add(new Shared.ImportExport.Model.TrifoliaImplementationGuideCardinalityDisplay()
{
cardinality = Shared.ImportExport.Model.CardinalityTypes.ZeroOrOne,
display = igSettings.GetSetting(IGSettingsManager.SettingProperty.CardinalityZeroToOne)
});
exportIg.CardinalityDisplay.Add(new Shared.ImportExport.Model.TrifoliaImplementationGuideCardinalityDisplay()
{
cardinality = Shared.ImportExport.Model.CardinalityTypes.ZeroToMany,
display = igSettings.GetSetting(IGSettingsManager.SettingProperty.CardinalityZeroOrMore)
});
exportIg.CardinalityDisplay.Add(new Shared.ImportExport.Model.TrifoliaImplementationGuideCardinalityDisplay()
{
cardinality = Shared.ImportExport.Model.CardinalityTypes.One,
display = igSettings.GetSetting(IGSettingsManager.SettingProperty.CardinalityOneToOne)
});
exportIg.CardinalityDisplay.Add(new Shared.ImportExport.Model.TrifoliaImplementationGuideCardinalityDisplay()
{
cardinality = Shared.ImportExport.Model.CardinalityTypes.OneToMany,
display = igSettings.GetSetting(IGSettingsManager.SettingProperty.CardinalityAtLeastOne)
});
exportIg.CustomSchematron = (from p in ig.SchematronPatterns
select new Shared.ImportExport.Model.TrifoliaImplementationGuideCustomSchematron()
{
phase = p.Phase,
patternId = p.PatternId,
Rule = p.PatternContent
}).ToList();
exportIg.CustomTemplateType = (from t in ig.TemplateTypes
select new Shared.ImportExport.Model.TrifoliaImplementationGuideCustomTemplateType()
{
templateTypeName = t.TemplateType.Name,
CustomName = t.Name,
Description = t.DetailsText
}).ToList();
var volume1Html = igSettings.GetSetting(IGSettingsManager.SettingProperty.Volume1Html);
if (!string.IsNullOrEmpty(volume1Html) || ig.Sections.Count > 0)
{
exportIg.Volume1 = new Shared.ImportExport.Model.TrifoliaImplementationGuideVolume1();
}
if (!string.IsNullOrEmpty(volume1Html))
{
exportIg.Volume1.Items.Add(volume1Html);
}
if (ig.Sections.Count > 0)
{
exportIg.Volume1.Items = (from s in ig.Sections.OrderBy(y => y.Order)
select new ExportImplementationGuideSection()
{
Heading = new Shared.ImportExport.Model.TrifoliaImplementationGuideVolume1SectionHeading()
{
Title = s.Heading,
Level = s.Level
},
Content = s.Content
}).ToList <object>();
}
var categoriesString = igSettings.GetSetting(IGSettingsManager.SettingProperty.Categories);
var categories = categoriesString.Split(',');
exportIg.Category = (from c in categories
select new ExportImplementationGuideCategory()
{
name = c
}).ToList();
return(exportIg);
}
private void UpdateProperties(ImplementationGuide implementationGuide, ImplementationGuideType igType, ImportImplementationGuide importImplementationGuide)
{
var importIgStatus = GetImportStatus(importImplementationGuide);
var organization = !string.IsNullOrEmpty(importImplementationGuide.organizationName) ? this.tdb.Organizations.SingleOrDefault(y => y.Name.ToLower() == importImplementationGuide.organizationName.ToLower()) : null;
if (implementationGuide.Organization != organization)
{
implementationGuide.Organization = organization;
}
if (implementationGuide.Name != importImplementationGuide.name)
{
implementationGuide.Name = importImplementationGuide.name;
}
if (implementationGuide.ImplementationGuideType != igType)
{
implementationGuide.ImplementationGuideType = igType;
}
if (implementationGuide.Version != importImplementationGuide.version)
{
implementationGuide.Version = importImplementationGuide.version;
}
if (implementationGuide.DisplayName != importImplementationGuide.displayName)
{
implementationGuide.DisplayName = importImplementationGuide.displayName;
}
if (implementationGuide.WebReadmeOverview != importImplementationGuide.WebReadmeOverview)
{
implementationGuide.WebReadmeOverview = importImplementationGuide.WebReadmeOverview;
}
if (implementationGuide.WebDisplayName != importImplementationGuide.webDisplayName)
{
implementationGuide.WebDisplayName = importImplementationGuide.webDisplayName;
}
if (implementationGuide.WebDescription != importImplementationGuide.WebDescription)
{
implementationGuide.WebDescription = importImplementationGuide.WebDescription;
}
if (implementationGuide.PublishStatus != importIgStatus)
{
implementationGuide.PublishStatus = importIgStatus;
}
}
