/// <exclude />
public override IEnumerable<PackageFragmentValidationResult> Validate()
{
_validationResult = new List<PackageFragmentValidationResult>();
if (this.Configuration.Count(f => f.Name == "Types") > 1)
{
_validationResult.AddFatal(GetText("DynamicDataTypePackageFragmentUninstaller.OnlyOneElement"));
return _validationResult;
}
XElement typesElement = this.Configuration.SingleOrDefault(f => f.Name == "Types");
_dataTypeDescriptorsToDelete = new List<DataTypeDescriptor>();
if (typesElement != null)
{
foreach (XElement typeElement in typesElement.Elements("Type").Reverse())
{
XAttribute typeIdAttribute = typeElement.Attribute("typeId");
if (typeIdAttribute == null)
{
_validationResult.AddFatal(GetText("DynamicDataTypePackageFragmentUninstaller.MissingAttribute").FormatWith("typeId"), typeElement);
continue;
}
Guid typeId;
if (!typeIdAttribute.TryGetGuidValue(out typeId))
{
_validationResult.AddFatal(GetText("DynamicDataTypePackageFragmentUninstaller.WrongAttributeFormat"), typeIdAttribute);
continue;
}
var dataTypeDescriptor = DynamicTypeManager.GetDataTypeDescriptor(typeId);
if (dataTypeDescriptor == null)
{
continue;
}
_dataTypeDescriptorsToDelete.Add(dataTypeDescriptor);
Type interfaceType = dataTypeDescriptor.GetInterfaceType();
var foreignRefereeTypes = DataReferenceFacade.GetRefereeTypes(interfaceType).Where(f => !_dataTypeDescriptorsToDelete.Any(g => g.GetInterfaceType() == f));
foreach (Type foreignRefereeType in foreignRefereeTypes)
{
// TODO: localize
_validationResult.AddFatal(string.Format("Data type '{0}' has references to type '{1}' about to be uninstalled. References must be removed before the package can be uninstalled.", foreignRefereeType, dataTypeDescriptor.TypeManagerTypeName),
typeIdAttribute);
}
UninstallerContext.AddPendingForDeletionDataType(interfaceType);
}
}
if (_validationResult.Count > 0)
{
_dataTypeDescriptorsToDelete = null;
}
return _validationResult;
}
/// <exclude />
public override IEnumerable <PackageFragmentValidationResult> Validate()
{
_validationResult = new List <PackageFragmentValidationResult>();
if (this.Configuration.Count(f => f.Name == "Types") > 1)
{
_validationResult.AddFatal(GetText("DynamicDataTypePackageFragmentUninstaller.OnlyOneElement"));
return(_validationResult);
}
XElement typesElement = this.Configuration.SingleOrDefault(f => f.Name == "Types");
_dataTypeDescriptorsToDelete = new List <DataTypeDescriptor>();
if (typesElement != null)
{
foreach (XElement typeElement in typesElement.Elements("Type").Reverse())
{
XAttribute typeIdAttribute = typeElement.Attribute("typeId");
if (typeIdAttribute == null)
{
_validationResult.AddFatal(GetText("DynamicDataTypePackageFragmentUninstaller.MissingAttribute").FormatWith("typeId"), typeElement);
continue;
}
Guid typeId;
if (!typeIdAttribute.TryGetGuidValue(out typeId))
{
_validationResult.AddFatal(GetText("DynamicDataTypePackageFragmentUninstaller.WrongAttributeFormat"), typeIdAttribute);
continue;
}
var dataTypeDescriptor = DynamicTypeManager.GetDataTypeDescriptor(typeId);
if (dataTypeDescriptor == null)
{
continue;
}
_dataTypeDescriptorsToDelete.Add(dataTypeDescriptor);
Type interfaceType = dataTypeDescriptor.GetInterfaceType();
var foreignRefereeTypes = DataReferenceFacade.GetRefereeTypes(interfaceType).Where(f => !_dataTypeDescriptorsToDelete.Any(g => g.GetInterfaceType() == f));
foreach (Type foreignRefereeType in foreignRefereeTypes)
{
// TODO: localize
_validationResult.AddFatal(string.Format("Data type '{0}' has references to type '{1}' about to be uninstalled. References must be removed before the package can be uninstalled.", foreignRefereeType, dataTypeDescriptor.TypeManagerTypeName),
typeIdAttribute);
}
UninstallerContext.AddPendingForDeletionDataType(interfaceType);
}
}
if (_validationResult.Count > 0)
{
_dataTypeDescriptorsToDelete = null;
}
return(_validationResult);
}
private void CheckForPotentialBrokenReferences(IData data, List <PackageFragmentValidationResult> validationResult,
Type type, DataScopeIdentifier dataScopeIdentifier, CultureInfo locale, DataKeyPropertyCollection dataKeyPropertyCollection)
{
var pagesReferencingPageTypes = new HashSet <string>();
var dataReferencingDataToBeUninstalled = new HashSet <string>();
List <IData> referees = data.GetReferees();
bool addToDelete = true;
foreach (IData referee in referees)
{
if (this.UninstallerContext.IsPendingForDeletionData(referee))
{
continue;
}
addToDelete = false;
if (referee is IPage && data is IPageType)
{
string pathToPage;
using (new DataScope(referee.DataSourceId.PublicationScope, referee.DataSourceId.LocaleScope))
{
pathToPage = GetPathToPage(referee as IPage);
}
if (!pagesReferencingPageTypes.Contains(pathToPage))
{
validationResult.AddFatal(Texts.DataPackageFragmentUninstaller_PageTypeIsReferenced(
data.GetLabel(), pathToPage));
pagesReferencingPageTypes.Add(pathToPage);
}
}
else
{
var refereeType = referee.DataSourceId.InterfaceType;
string label = referee.GetLabel();
string key = label + refereeType.FullName;
if (!dataReferencingDataToBeUninstalled.Contains(key))
{
validationResult.AddFatal(Texts.DataPackageFragmentUninstaller_DataIsReferenced(
data.GetLabel(),
type.FullName,
label,
refereeType.FullName));
dataReferencingDataToBeUninstalled.Add(key);
}
}
}
if (addToDelete)
{
AddDataToDelete(type, dataScopeIdentifier, locale, dataKeyPropertyCollection);
}
}
/// <exclude />
public override IEnumerable<PackageFragmentValidationResult> Validate()
{
List<PackageFragmentValidationResult> validationResults = new List<PackageFragmentValidationResult>();
if (this.Configuration.Count(f => f.Name == "Locales") > 1)
{
validationResults.AddFatal(GetText("VirtualElementProviderNodePackageFragmentUninstaller.OnlyOneElement"));
return validationResults;
}
XElement localesElement = this.Configuration.SingleOrDefault(f => f.Name == "Locales");
_culturesToUninstall = new List<CultureInfo>();
if (localesElement != null)
{
XAttribute oldDefaultAttribute = localesElement.Attribute("oldDefault");
if (oldDefaultAttribute != null)
{
_oldDefaultCultureInfo = CultureInfo.CreateSpecificCulture(oldDefaultAttribute.Value);
}
foreach (XElement localeElement in localesElement.Elements("Locale").Reverse())
{
CultureInfo locale = CultureInfo.CreateSpecificCulture(localeElement.Attribute("name").Value);
if ((_oldDefaultCultureInfo == null) && (LocalizationFacade.IsDefaultLocale(locale)))
{
// Locale is default -> not possible to unintall
validationResults.AddFatal(GetText("VirtualElementProviderNodePackageFragmentUninstaller.OnlyOneElement"));
continue;
}
if (LocalizationFacade.IsOnlyActiveLocaleForSomeUsers(locale))
{
// only active for the a user
validationResults.AddFatal(GetText("VirtualElementProviderNodePackageFragmentUninstaller.OnlyOneElement"));
continue;
}
if (LocalizationFacade.IsLocaleInstalled(locale))
{
_culturesToUninstall.Add(locale);
}
}
}
if (validationResults.Count > 0)
{
_culturesToUninstall = null;
_oldDefaultCultureInfo = null;
}
return validationResults;
}
/// <exclude />
public override IEnumerable <PackageFragmentValidationResult> Validate()
{
List <PackageFragmentValidationResult> validationResults = new List <PackageFragmentValidationResult>();
if (this.Configuration.Count(f => f.Name == "Locales") > 1)
{
validationResults.AddFatal(GetText("VirtualElementProviderNodePackageFragmentUninstaller.OnlyOneElement"));
return(validationResults);
}
XElement localesElement = this.Configuration.SingleOrDefault(f => f.Name == "Locales");
_culturesToUninstall = new List <CultureInfo>();
if (localesElement != null)
{
XAttribute oldDefaultAttribute = localesElement.Attribute("oldDefault");
if (oldDefaultAttribute != null)
{
_oldDefaultCultureInfo = CultureInfo.CreateSpecificCulture(oldDefaultAttribute.Value);
}
foreach (XElement localeElement in localesElement.Elements("Locale").Reverse())
{
CultureInfo locale = CultureInfo.CreateSpecificCulture(localeElement.Attribute("name").Value);
if ((_oldDefaultCultureInfo == null) && (LocalizationFacade.IsDefaultLocale(locale)))
{
// Locale is default -> not possible to unintall
validationResults.AddFatal(GetText("VirtualElementProviderNodePackageFragmentUninstaller.OnlyOneElement"));
continue;
}
if (LocalizationFacade.IsOnlyActiveLocaleForSomeUsers(locale))
{
// only active for the a user
validationResults.AddFatal(GetText("VirtualElementProviderNodePackageFragmentUninstaller.OnlyOneElement"));
continue;
}
if (LocalizationFacade.IsLocaleInstalled(locale))
{
_culturesToUninstall.Add(locale);
}
}
}
if (validationResults.Count > 0)
{
_culturesToUninstall = null;
_oldDefaultCultureInfo = null;
}
return(validationResults);
}
/// <exclude />
public override IEnumerable<PackageFragmentValidationResult> Validate()
{
var validationResult = new List<PackageFragmentValidationResult>();
Guid packageId = this.InstallerContext.PackageInformation.Id;
if(LicenseDefinitionManager.GetLicenseDefinition(packageId) != null)
{
_licenseFileExists = true;
return validationResult;
}
XElement publicKeyElement = this.Configuration.SingleOrDefault(f => f.Name == "RSAKeyValue");
if (publicKeyElement == null)
{
validationResult.AddFatal(GetResourceString("PackageLicenseFragmentInstaller.MissingPublicKeyElement"));
return validationResult;
}
_publicKeyXml = publicKeyElement.ToString();
string validated = LicenseServerFacade.ValidateTrialLicenseDefinitionRequest(InstallationInformationFacade.InstallationId, packageId, _publicKeyXml);
if (validated != "OK")
{
validationResult.Add(new PackageFragmentValidationResult(PackageFragmentValidationResultType.Fatal, validated));
}
return validationResult;
}
/// <exclude />
public override IEnumerable <PackageFragmentValidationResult> Validate()
{
List <PackageFragmentValidationResult> validationResults = new List <PackageFragmentValidationResult>();
if (this.Configuration.Count() > 2)
{
validationResults.AddFatal(
GetResourceString("ConfigurationTransformationPackageFragmentInstaller.ExpectedExactlyTwoElements")
.FormatWith(_installElementName, _uninstallElementName));
}
ValidateXslt(
validationResults,
() => this.InstallElement,
_installElementName,
() => this.InstallElement.Attribute(_xsltFilePathAttributeName),
() => this.InstallXsltFilePath,
this.InstallerContext.ZipFileSystem,
true);
if (validationResults.Count == 0 &&
this.InstallerContext.PackageInformation.CanBeUninstalled)
{
ValidateXslt(
validationResults,
() => this.UninstallElement,
_uninstallElementName,
() => this.UninstallElement.Attribute(_xsltFilePathAttributeName),
() => this.UninstallXsltFilePath,
this.InstallerContext.ZipFileSystem,
false);
}
return(validationResults);
}
/// <exclude />
public override IEnumerable <PackageFragmentValidationResult> Validate()
{
var validationResult = new List <PackageFragmentValidationResult>();
Guid packageId = this.InstallerContext.PackageInformation.Id;
if (LicenseDefinitionManager.GetLicenseDefinition(packageId) != null)
{
_licenseFileExists = true;
return(validationResult);
}
XElement publicKeyElement = this.Configuration.SingleOrDefault(f => f.Name == "RSAKeyValue");
if (publicKeyElement == null)
{
validationResult.AddFatal(GetResourceString("PackageLicenseFragmentInstaller.MissingPublicKeyElement"));
return(validationResult);
}
_publicKeyXml = publicKeyElement.ToString();
string validated = LicenseServerFacade.ValidateTrialLicenseDefinitionRequest(InstallationInformationFacade.InstallationId, packageId, _publicKeyXml);
if (validated != "OK")
{
validationResult.Add(new PackageFragmentValidationResult(PackageFragmentValidationResultType.Fatal, validated));
}
return(validationResult);
}
/// <exclude />
public override IEnumerable <PackageFragmentValidationResult> Validate()
{
_xsls = new List <XslTransformation>();
var validationResult = new List <PackageFragmentValidationResult>();
var filesElement = this.ConfigurationParent.GetSingleConfigurationElement("XslFiles", validationResult, false);
if (filesElement == null)
{
return(validationResult);
}
foreach (XElement fileElement in filesElement.Elements("XslFile"))
{
XAttribute pathXMLAttribute = fileElement.Attribute(Installer.TargetXmlAttributeName);
XAttribute pathXSLAttribute = fileElement.Attribute(Installer.UninstallXslAttributeName);
if (pathXMLAttribute == null)
{
validationResult.AddFatal(Texts.PackageFragmentInstaller_MissingAttribute(Installer.TargetXmlAttributeName), fileElement);
continue;
}
if (pathXSLAttribute == null)
{
//if there isn no uninstall xsl
continue;
}
string inputPathXMLAttributeValue = PathUtil.Resolve(pathXMLAttribute.Value);
string inpuPathXSLAttributeValue = pathXSLAttribute.Value;
_xsls.Add(new XslTransformation
{
pathXml = inputPathXMLAttributeValue,
pathXsl = inpuPathXSLAttributeValue
});
}
if (validationResult.Count > 0)
{
_xsls = null;
}
return(validationResult);
}
private static bool ParseBoolAttribute(XAttribute attribute, List <PackageFragmentValidationResult> validationResult,
ref bool resultValue)
{
if (attribute == null)
{
return(true);
}
if (!attribute.TryGetBoolValue(out resultValue))
{
validationResult.AddFatal(Texts.FilePackageFragmentInstaller_WrongAttributeBoolFormat, attribute);
return(false);
}
return(true);
}
/// <exclude />
public override IEnumerable<PackageFragmentValidationResult> Validate()
{
_xsls = new List<XslTransformation>();
var validationResult = new List<PackageFragmentValidationResult>();
var filesElement = this.ConfigurationParent.GetSingleConfigurationElement("XslFiles", validationResult, false);
if (filesElement == null)
{
return validationResult;
}
foreach (XElement fileElement in filesElement.Elements("XslFile"))
{
XAttribute pathXMLAttribute = fileElement.Attribute(Installer.TargetXmlAttributeName);
XAttribute pathXSLAttribute = fileElement.Attribute(Installer.UninstallXslAttributeName);
if (pathXMLAttribute == null)
{
validationResult.AddFatal(Texts.PackageFragmentInstaller_MissingAttribute(Installer.TargetXmlAttributeName), fileElement);
continue;
}
if (pathXSLAttribute == null)
{
//if there isn no uninstall xsl
continue;
}
string inputPathXMLAttributeValue = PathUtil.Resolve(pathXMLAttribute.Value);
string inpuPathXSLAttributeValue = pathXSLAttribute.Value;
_xsls.Add(new XslTransformation
{
pathXml = inputPathXMLAttributeValue,
pathXsl = inpuPathXSLAttributeValue
});
}
if (validationResult.Count > 0)
{
_xsls = null;
}
return validationResult;
}
/// <exclude />
public override IEnumerable <PackageFragmentValidationResult> Validate()
{
_validationResult = new List <PackageFragmentValidationResult>();
_dataKeysToBeInstalled = new Dictionary <Type, TypeKeyInstallationData>();
_dataKeysToBeInstalledByTypeId = new Dictionary <Guid, TypeKeyInstallationData>();
_missingDataReferences = new Dictionary <Type, HashSet <KeyValuePair <string, object> > >();
if (this.Configuration.Count(f => f.Name == "Types") > 1)
{
_validationResult.AddFatal(Texts.DataPackageFragmentInstaller_OnlyOneElement);
return(_validationResult);
}
_dataTypes = new List <DataType>();
ValidateAndLoadConfiguration();
foreach (DataType dataType in _dataTypes)
{
dataType.InterfaceType = TypeManager.TryGetType(dataType.InterfaceTypeName);
if (dataType.IsDynamicAdded || this.InstallerContext.IsDataTypePending(dataType.InterfaceTypeName))
{
ValidateDynamicAddedType(dataType);
}
else
{
ValidateNonDynamicAddedType(dataType);
}
}
if (_validationResult.Count > 0)
{
_dataTypes = null;
}
return(_validationResult);
}
/// <exclude />
public override IEnumerable<PackageFragmentValidationResult> Validate()
{
_validationResult = new List<PackageFragmentValidationResult>();
_dataKeysToBeInstalled = new Dictionary<Type, TypeKeyInstallationData>();
_missingDataReferences = new Dictionary<Type, HashSet<KeyValuePair<string, object>>>();
if (this.Configuration.Count(f => f.Name == "Types") > 1)
{
_validationResult.AddFatal(Texts.DataPackageFragmentInstaller_OnlyOneElement);
return _validationResult;
}
_dataTypes = new List<DataType>();
ValidateAndLoadConfiguration();
foreach (DataType dataType in _dataTypes)
{
dataType.InterfaceType = TypeManager.TryGetType(dataType.InterfaceTypeName);
if (dataType.IsDynamicAdded || this.InstallerContext.IsDataTypePending(dataType.InterfaceTypeName))
{
ValidateDynamicAddedType(dataType);
}
else
{
ValidateNonDynamicAddedType(dataType);
}
}
if (_validationResult.Count > 0)
{
_dataTypes = null;
}
return _validationResult;
}
/// <exclude />
public override IEnumerable<PackageFragmentValidationResult> Validate()
{
List<PackageFragmentValidationResult> validationResults = new List<PackageFragmentValidationResult>();
if (this.Configuration.Count() > 2)
{
validationResults.AddFatal(
GetResourceString("ConfigurationTransformationPackageFragmentInstaller.ExpectedExactlyTwoElements")
.FormatWith(_installElementName, _uninstallElementName));
}
ValidateXslt(
validationResults,
() => this.InstallElement,
_installElementName,
() => this.InstallElement.Attribute(_xsltFilePathAttributeName),
() => this.InstallXsltFilePath,
this.InstallerContext.ZipFileSystem,
true);
if (validationResults.Count == 0
&& this.InstallerContext.PackageInformation.CanBeUninstalled)
{
ValidateXslt(
validationResults,
() => this.UninstallElement,
_uninstallElementName,
() => this.UninstallElement.Attribute(_xsltFilePathAttributeName),
() => this.UninstallXsltFilePath,
this.InstallerContext.ZipFileSystem,
false);
}
return validationResults;
}
/// <exclude />
public override IEnumerable<PackageFragmentValidationResult> Validate()
{
var validationResult = new List<PackageFragmentValidationResult>();
if (this.Configuration.Count(f => f.Name == "Types") > 1)
{
validationResult.AddFatal(Texts.DataPackageFragmentUninstaller_OnlyOneElement);
return validationResult;
}
_dataToDelete = new List<DataType>();
XElement typesElement = this.Configuration.SingleOrDefault(f => f.Name == "Types");
if (typesElement == null)
{
return validationResult;
}
foreach (XElement typeElement in typesElement.Elements("Type").Reverse())
{
XAttribute typeAttribute = typeElement.Attribute("type");
XAttribute dataScopeIdentifierAttribute = typeElement.Attribute("dataScopeIdentifier");
if (typeAttribute == null)
{
validationResult.AddFatal(Texts.DataPackageFragmentUninstaller_MissingAttribute("type"), typeElement);
continue;
}
if (dataScopeIdentifierAttribute == null)
{
validationResult.AddFatal(Texts.DataPackageFragmentUninstaller_MissingAttribute("dataScopeIdentifier"), typeElement);
continue;
}
Type type = TypeManager.TryGetType(typeAttribute.Value);
if (type == null) continue;
if (!DataFacade.GetAllInterfaces().Contains(type)) continue;
DataScopeIdentifier dataScopeIdentifier;
try
{
dataScopeIdentifier = DataScopeIdentifier.Deserialize(dataScopeIdentifierAttribute.Value);
}
catch (Exception)
{
validationResult.AddFatal("Wrong DataScopeIdentifier ({0}) name in the configuration".FormatWith(dataScopeIdentifierAttribute.Value), dataScopeIdentifierAttribute);
continue;
}
foreach (XElement datasElement in typeElement.Elements("Datas").Reverse())
{
CultureInfo locale = null;
XAttribute localeAttribute = datasElement.Attribute("locale");
if (localeAttribute != null)
{
locale = CultureInfo.CreateSpecificCulture(localeAttribute.Value);
}
foreach (XElement keysElement in datasElement.Elements("Keys").Reverse())
{
bool allKeyPropertiesValidated = true;
var dataKeyPropertyCollection = new DataKeyPropertyCollection();
foreach (XElement keyElement in keysElement.Elements("Key"))
{
XAttribute keyNameAttribute = keyElement.Attribute("name");
XAttribute keyValueAttribute = keyElement.Attribute("value");
if (keyNameAttribute == null || keyValueAttribute == null)
{
if (keyNameAttribute == null) validationResult.AddFatal(GetText("DataPackageFragmentUninstaller.MissingAttribute").FormatWith("name"), keyElement);
if (keyValueAttribute == null) validationResult.AddFatal(GetText("DataPackageFragmentUninstaller.MissingAttribute").FormatWith("value"), keyElement);
allKeyPropertiesValidated = false;
continue;
}
string keyName = keyNameAttribute.Value;
PropertyInfo keyPropertyInfo = type.GetPropertiesRecursively().SingleOrDefault(f => f.Name == keyName);
if (keyPropertyInfo == null)
{
validationResult.AddFatal(GetText("DataPackageFragmentUninstaller.MissingKeyProperty").FormatWith(type, keyName));
allKeyPropertiesValidated = false;
}
else
{
try
{
object keyValue = ValueTypeConverter.Convert(keyValueAttribute.Value, keyPropertyInfo.PropertyType);
dataKeyPropertyCollection.AddKeyProperty(keyName, keyValue);
}
catch (Exception)
{
allKeyPropertiesValidated = false;
validationResult.AddFatal(GetText("DataPackageFragmentUninstaller.DataPackageFragmentUninstaller").FormatWith(keyValueAttribute.Value, keyPropertyInfo.PropertyType));
}
}
}
if (allKeyPropertiesValidated)
{
IData data;
using (new DataScope(dataScopeIdentifier, locale))
{
data = DataFacade.TryGetDataByUniqueKey(type, dataKeyPropertyCollection);
}
if (data != null)
{
CheckForPotentialBrokenReferences(data, validationResult, type, dataScopeIdentifier, locale, dataKeyPropertyCollection);
}
}
}
}
}
if (validationResult.Count > 0)
{
_dataToDelete = null;
}
return validationResult;
}
public override IEnumerable<PackageFragmentValidationResult> Validate()
{
var validationResult = new List<PackageFragmentValidationResult>();
if (this.Configuration.Count(f => f.Name == "PackageVersions") > 1)
{
validationResult.AddFatal(Texts.PackageVersionBumperFragmentInstaller_OnlyOneElement);
return validationResult;
}
XElement packageVersionsElement = this.Configuration.SingleOrDefault(f => f.Name == "PackageVersions");
_packageToRestore = new Dictionary<Guid, string>();
if (packageVersionsElement != null)
{
foreach (XElement packageVersionElement in packageVersionsElement.Elements("PackageVersion"))
{
XAttribute packageIdAttribute = packageVersionElement.Attribute("packageId");
XAttribute oldVersionAttribute = packageVersionElement.Attribute("oldVersion");
if (packageIdAttribute == null)
{
validationResult.AddFatal(Texts.PackageVersionBumperFragmentUninstaller_MissingAttribute("packageId"), packageVersionElement);
continue;
}
if (oldVersionAttribute == null)
{
validationResult.AddFatal(Texts.PackageVersionBumperFragmentUninstaller_MissingAttribute("newVersion"), packageVersionElement);
continue;
}
Guid packageId;
if (!packageIdAttribute.TryGetGuidValue(out packageId))
{
validationResult.AddFatal(Texts.PackageVersionBumperFragmentUninstaller_WrongAttributeGuidFormat, packageIdAttribute);
continue;
}
if (_packageToRestore.ContainsKey(packageId))
{
validationResult.AddFatal(Texts.PackageVersionBumperFragmentUninstaller_PackageIdDuplicate(packageId), packageIdAttribute);
continue;
}
Version version;
try
{
version = new Version(oldVersionAttribute.Value);
}
catch
{
validationResult.AddFatal(Texts.PackageVersionBumperFragmentUninstaller_WrongAttributeVersionFormat, oldVersionAttribute);
continue;
}
_packageToRestore.Add(packageId, version.ToString());
}
}
if (validationResult.Count > 0)
{
_packageToRestore = null;
_installedPackages = null;
}
return validationResult;
}
/// <exclude />
public override IEnumerable <PackageFragmentValidationResult> Validate()
{
var validationResult = new List <PackageFragmentValidationResult>();
if (this.Configuration.Count(f => f.Name == "Types") > 1)
{
validationResult.AddFatal(GetText("DataTypePackageFragmentInstaller.OnlyOneElement"));
return(validationResult);
}
XElement typesElement = this.Configuration.SingleOrDefault(f => f.Name == "Types");
if (typesElement == null)
{
validationResult.AddFatal(GetText("DataTypePackageFragmentInstaller.MissingElement"));
return(validationResult);
}
_typesToInstall = new List <DataTypeDescriptor>();
foreach (XElement typeElement in typesElement.Elements("Type"))
{
XAttribute nameAttribute = typeElement.Attribute("name");
if (nameAttribute == null)
{
validationResult.AddFatal(GetText("DataTypePackageFragmentInstaller.MissingAttribute").FormatWith("name"), typeElement);
continue;
}
Type type = TypeManager.TryGetType(nameAttribute.Value);
if (type == null)
{
validationResult.AddFatal(GetText("DataTypePackageFragmentInstaller.TypeNotConfigured").FormatWith(nameAttribute.Value));
}
else if (!typeof(IData).IsAssignableFrom(type))
{
validationResult.AddFatal(GetText("DataTypePackageFragmentInstaller.TypeNotInheriting").FormatWith(type, typeof(IData)));
}
else if (DataFacade.GetAllKnownInterfaces().Contains(type))
{
validationResult.AddFatal(GetText("DataTypePackageFragmentInstaller.TypeExists").FormatWith(type));
}
else
{
DataTypeDescriptor dataTypeDescriptor = null;
try
{
dataTypeDescriptor = DynamicTypeManager.GetDataTypeDescriptor(type);
dataTypeDescriptor.Validate();
}
catch (Exception ex)
{
validationResult.AddFatal(GetText("DataTypePackageFragmentInstaller.InterfaceCodeError").FormatWith(type));
validationResult.AddFatal(ex);
Log.LogError(LogTitle, ex);
}
if (dataTypeDescriptor != null)
{
_typesToInstall.Add(dataTypeDescriptor);
this.InstallerContext.AddPendingDataType(type);
}
}
}
if (validationResult.Count > 0)
{
_typesToInstall = null;
}
return(validationResult);
}
/// <exclude />
public override IEnumerable<PackageFragmentValidationResult> Validate()
{
var validationResult = new List<PackageFragmentValidationResult>();
if (this.Configuration.Count(f => f.Name == "Files") > 1)
{
validationResult.AddFatal(Texts.FilePackageFragmentInstaller_OnlyOneFilesElement, this.ConfigurationParent);
return validationResult;
}
if (this.Configuration.Count(f => f.Name == "Directories") > 1)
{
validationResult.AddFatal(Texts.FilePackageFragmentInstaller_OnlyOneDirectoriesElement, this.ConfigurationParent);
return validationResult;
}
XElement filesElement = this.Configuration.SingleOrDefault(f => f.Name == "Files");
XElement directoriesElement = this.Configuration.SingleOrDefault(f => f.Name == "Directories");
_filesToCopy = new List<FileToCopy>();
_directoriesToDelete = new List<string>();
if (filesElement != null)
{
foreach (XElement fileElement in filesElement.Elements("File"))
{
XAttribute sourceFilenameAttribute = fileElement.Attribute("sourceFilename");
XAttribute targetFilenameAttribute = fileElement.Attribute("targetFilename");
if (sourceFilenameAttribute == null)
{
validationResult.AddFatal(Texts.FilePackageFragmentInstaller_MissingAttribute("sourceFilename"), fileElement);
continue;
}
if (targetFilenameAttribute == null)
{
validationResult.AddFatal(Texts.FilePackageFragmentInstaller_MissingAttribute("targetFilename"), fileElement);
continue;
}
XAttribute allowOverwriteAttribute = fileElement.Attribute("allowOverwrite");
XAttribute assemblyLoadAttribute = fileElement.Attribute("assemblyLoad");
XAttribute deleteTargetDirectoryAttribute = fileElement.Attribute("deleteTargetDirectory");
XAttribute onlyUpdateAttribute = fileElement.Attribute("onlyUpdate");
if (deleteTargetDirectoryAttribute != null)
{
validationResult.AddFatal(Texts.FilePackageFragmentInstaller_DeleteTargetDirectoryNotAllowed, fileElement);
continue;
}
bool allowOverwrite = false;
if (!ParseBoolAttribute(allowOverwriteAttribute, validationResult, ref allowOverwrite))
{
continue;
}
bool loadAssembly = false;
if (!ParseBoolAttribute(assemblyLoadAttribute, validationResult, ref loadAssembly))
{
continue;
}
bool onlyUpdate = false;
if (!ParseBoolAttribute(onlyUpdateAttribute, validationResult, ref onlyUpdate))
{
continue;
}
string sourceFilename = sourceFilenameAttribute.Value;
if (!this.InstallerContext.ZipFileSystem.ContainsFile(sourceFilename))
{
validationResult.AddFatal(Texts.FilePackageFragmentInstaller_MissingFile(sourceFilename), sourceFilenameAttribute);
continue;
}
if (loadAssembly && onlyUpdate)
{
validationResult.AddFatal(Texts.FilePackageFragmentInstaller_OnlyUpdateNotAllowedWithLoadAssemlby, onlyUpdateAttribute);
continue;
}
string targetFilename = PathUtil.Resolve(targetFilenameAttribute.Value);
if (C1File.Exists(targetFilename))
{
if (!allowOverwrite && !onlyUpdate)
{
validationResult.AddFatal(Texts.FilePackageFragmentInstaller_FileExists(targetFilename), targetFilenameAttribute);
continue;
}
if (((C1File.GetAttributes(targetFilename) & FileAttributes.ReadOnly) > 0) && !allowOverwrite)
{
validationResult.AddFatal(Texts.FilePackageFragmentInstaller_FileReadOnly(targetFilename), targetFilenameAttribute);
continue;
}
}
else if (onlyUpdate)
{
Log.LogVerbose(LogTitle, "Skipping updating of the file '{0}' because it does not exist", targetFilename);
continue; // Target file does not, so skip this
}
var fileToCopy = new FileToCopy
{
SourceFilename = sourceFilename,
TargetRelativeFilePath = targetFilenameAttribute.Value,
TargetFilePath = targetFilename,
Overwrite = allowOverwrite || onlyUpdate
};
_filesToCopy.Add(fileToCopy);
if (loadAssembly)
{
string tempFilename = Path.Combine(this.InstallerContext.TempDirectory, Path.GetFileName(targetFilename));
this.InstallerContext.ZipFileSystem.WriteFileToDisk(sourceFilename, tempFilename);
PackageAssemblyHandler.AddAssembly(tempFilename);
}
}
}
if (directoriesElement != null)
{
foreach (XElement directoryElement in directoriesElement.Elements("Directory"))
{
XAttribute sourceDirectoryAttribute = directoryElement.Attribute("sourceDirectory");
XAttribute targetDirectoryAttribute = directoryElement.Attribute("targetDirectory");
if (sourceDirectoryAttribute == null)
{
validationResult.AddFatal(Texts.FilePackageFragmentInstaller_MissingAttribute("sourceDirectory"), directoryElement);
continue;
}
if (targetDirectoryAttribute == null)
{
validationResult.AddFatal(Texts.FilePackageFragmentInstaller_MissingAttribute("targetDirectory"), directoryElement);
continue;
}
XAttribute allowOverwriteAttribute = directoryElement.Attribute("allowOverwrite");
XAttribute assemblyLoadAttribute = directoryElement.Attribute("assemblyLoad");
XAttribute deleteTargetDirectoryAttribute = directoryElement.Attribute("deleteTargetDirectory");
XAttribute onlyUpdateAttribute = directoryElement.Attribute("onlyUpdate");
if (assemblyLoadAttribute != null)
{
validationResult.AddFatal(Texts.FilePackageFragmentInstaller_AssemblyLoadNotAllowed, directoryElement);
continue;
}
if (onlyUpdateAttribute != null)
{
validationResult.AddFatal(Texts.FilePackageFragmentInstaller_OnlyUpdateNotAllowed, directoryElement);
continue;
}
bool allowOverwrite = false;
if (!ParseBoolAttribute(allowOverwriteAttribute, validationResult, ref allowOverwrite))
{
continue;
}
bool deleteTargetDirectory = false;
if (!ParseBoolAttribute(deleteTargetDirectoryAttribute, validationResult, ref deleteTargetDirectory))
{
continue;
}
string sourceDirectory = sourceDirectoryAttribute.Value;
if (!this.InstallerContext.ZipFileSystem.ContainsDirectory(sourceDirectory))
{
validationResult.AddFatal(Texts.FilePackageFragmentInstaller_MissingDirectory(sourceDirectory), sourceDirectoryAttribute);
continue;
}
string targetDirectory = PathUtil.Resolve(targetDirectoryAttribute.Value);
if (deleteTargetDirectory)
{
if (C1Directory.Exists(targetDirectory))
{
_directoriesToDelete.Add(targetDirectory);
}
}
foreach (string sourceFilename in this.InstallerContext.ZipFileSystem.GetFilenames(sourceDirectory))
{
string resolvedSourceFilename = sourceFilename.Remove(0, sourceDirectory.Length);
if (resolvedSourceFilename.StartsWith("/"))
{
resolvedSourceFilename = resolvedSourceFilename.Remove(0, 1);
}
string targetFilename = Path.Combine(targetDirectory, resolvedSourceFilename);
if (C1File.Exists(targetFilename) && !deleteTargetDirectory && !allowOverwrite)
{
validationResult.AddFatal(Texts.FilePackageFragmentInstaller_FileExists(targetFilename), targetDirectoryAttribute);
continue;
}
var fileToCopy = new FileToCopy
{
SourceFilename = sourceFilename,
TargetRelativeFilePath = Path.Combine(targetDirectoryAttribute.Value, resolvedSourceFilename),
TargetFilePath = targetFilename,
Overwrite = allowOverwrite
};
_filesToCopy.Add(fileToCopy);
}
}
}
if (validationResult.Count > 0)
{
_filesToCopy = null;
_directoriesToDelete = null;
}
return validationResult;
}
/// <exclude />
public override IEnumerable <PackageFragmentValidationResult> Validate()
{
var validationResult = new List <PackageFragmentValidationResult>();
if (this.Configuration.Count(f => f.Name == "Files") > 1)
{
validationResult.AddFatal(Texts.FilePackageFragmentInstaller_OnlyOneFilesElement, this.ConfigurationParent);
return(validationResult);
}
if (this.Configuration.Count(f => f.Name == "Directories") > 1)
{
validationResult.AddFatal(Texts.FilePackageFragmentInstaller_OnlyOneDirectoriesElement, this.ConfigurationParent);
return(validationResult);
}
XElement filesElement = this.Configuration.SingleOrDefault(f => f.Name == "Files");
XElement directoriesElement = this.Configuration.SingleOrDefault(f => f.Name == "Directories");
_filesToCopy = new List <FileToCopy>();
_directoriesToDelete = new List <string>();
if (filesElement != null)
{
foreach (XElement fileElement in filesElement.Elements("File"))
{
XAttribute sourceFilenameAttribute = fileElement.Attribute("sourceFilename");
XAttribute targetFilenameAttribute = fileElement.Attribute("targetFilename");
if (sourceFilenameAttribute == null)
{
validationResult.AddFatal(Texts.FilePackageFragmentInstaller_MissingAttribute("sourceFilename"), fileElement);
continue;
}
if (targetFilenameAttribute == null)
{
validationResult.AddFatal(Texts.FilePackageFragmentInstaller_MissingAttribute("targetFilename"), fileElement);
continue;
}
XAttribute allowOverwriteAttribute = fileElement.Attribute("allowOverwrite");
XAttribute assemblyLoadAttribute = fileElement.Attribute("assemblyLoad");
XAttribute deleteTargetDirectoryAttribute = fileElement.Attribute("deleteTargetDirectory");
XAttribute onlyUpdateAttribute = fileElement.Attribute("onlyUpdate");
XAttribute onlyAddAttribute = fileElement.Attribute("onlyAdd");
if (deleteTargetDirectoryAttribute != null)
{
validationResult.AddFatal(Texts.FilePackageFragmentInstaller_DeleteTargetDirectoryNotAllowed, fileElement);
continue;
}
bool allowOverwrite = false;
if (!ParseBoolAttribute(allowOverwriteAttribute, validationResult, ref allowOverwrite))
{
continue;
}
bool loadAssembly = false;
if (!ParseBoolAttribute(assemblyLoadAttribute, validationResult, ref loadAssembly))
{
continue;
}
bool onlyUpdate = false;
if (!ParseBoolAttribute(onlyUpdateAttribute, validationResult, ref onlyUpdate))
{
continue;
}
bool onlyAdd = false;
if (!ParseBoolAttribute(onlyAddAttribute, validationResult, ref onlyAdd))
{
continue;
}
string sourceFilename = sourceFilenameAttribute.Value;
if (!this.InstallerContext.ZipFileSystem.ContainsFile(sourceFilename))
{
validationResult.AddFatal(Texts.FilePackageFragmentInstaller_MissingFile(sourceFilename), sourceFilenameAttribute);
continue;
}
if (loadAssembly && onlyUpdate)
{
validationResult.AddFatal(Texts.FilePackageFragmentInstaller_OnlyUpdateNotAllowedWithLoadAssemlby, onlyUpdateAttribute);
continue;
}
if (onlyAdd && onlyUpdate)
{
validationResult.AddFatal(Texts.FilePackageFragmentInstaller_OnlyUpdateAndOnlyAddNotAllowed, onlyUpdateAttribute);
continue;
}
if (onlyAdd && allowOverwrite)
{
validationResult.AddFatal(Texts.FilePackageFragmentInstaller_OnlyAddAndAllowOverwriteNotAllowed, onlyAddAttribute);
continue;
}
string targetFilename = PathUtil.Resolve(targetFilenameAttribute.Value);
if (C1File.Exists(targetFilename))
{
if (onlyAdd)
{
Log.LogVerbose(LogTitle, "Skipping adding of the file '{0}' because it already exist and is marked 'onlyAdd'", targetFilename);
continue; // Target file does not, so skip this
}
if (!allowOverwrite && !onlyUpdate)
{
validationResult.AddFatal(Texts.FilePackageFragmentInstaller_FileExists(targetFilename), targetFilenameAttribute);
continue;
}
if (((C1File.GetAttributes(targetFilename) & FileAttributes.ReadOnly) > 0) && !allowOverwrite)
{
validationResult.AddFatal(Texts.FilePackageFragmentInstaller_FileReadOnly(targetFilename), targetFilenameAttribute);
continue;
}
}
else if (onlyUpdate)
{
Log.LogVerbose(LogTitle, "Skipping updating of the file '{0}' because it does not exist", targetFilename);
continue; // Target file does not, so skip this
}
var fileToCopy = new FileToCopy
{
SourceFilename = sourceFilename,
TargetRelativeFilePath = targetFilenameAttribute.Value,
TargetFilePath = targetFilename,
Overwrite = allowOverwrite || onlyUpdate
};
_filesToCopy.Add(fileToCopy);
if (loadAssembly)
{
string tempFilename = Path.Combine(this.InstallerContext.TempDirectory, Path.GetFileName(targetFilename));
this.InstallerContext.ZipFileSystem.WriteFileToDisk(sourceFilename, tempFilename);
PackageAssemblyHandler.AddAssembly(tempFilename);
}
}
}
if (directoriesElement != null)
{
foreach (XElement directoryElement in directoriesElement.Elements("Directory"))
{
XAttribute sourceDirectoryAttribute = directoryElement.Attribute("sourceDirectory");
XAttribute targetDirectoryAttribute = directoryElement.Attribute("targetDirectory");
if (sourceDirectoryAttribute == null)
{
validationResult.AddFatal(Texts.FilePackageFragmentInstaller_MissingAttribute("sourceDirectory"), directoryElement);
continue;
}
if (targetDirectoryAttribute == null)
{
validationResult.AddFatal(Texts.FilePackageFragmentInstaller_MissingAttribute("targetDirectory"), directoryElement);
continue;
}
XAttribute allowOverwriteAttribute = directoryElement.Attribute("allowOverwrite");
XAttribute assemblyLoadAttribute = directoryElement.Attribute("assemblyLoad");
XAttribute deleteTargetDirectoryAttribute = directoryElement.Attribute("deleteTargetDirectory");
XAttribute onlyUpdateAttribute = directoryElement.Attribute("onlyUpdate");
if (assemblyLoadAttribute != null)
{
validationResult.AddFatal(Texts.FilePackageFragmentInstaller_AssemblyLoadNotAllowed, directoryElement);
continue;
}
if (onlyUpdateAttribute != null)
{
validationResult.AddFatal(Texts.FilePackageFragmentInstaller_OnlyUpdateNotAllowed, directoryElement);
continue;
}
bool allowOverwrite = false;
if (!ParseBoolAttribute(allowOverwriteAttribute, validationResult, ref allowOverwrite))
{
continue;
}
bool deleteTargetDirectory = false;
if (!ParseBoolAttribute(deleteTargetDirectoryAttribute, validationResult, ref deleteTargetDirectory))
{
continue;
}
string sourceDirectory = sourceDirectoryAttribute.Value;
if (!this.InstallerContext.ZipFileSystem.ContainsDirectory(sourceDirectory))
{
validationResult.AddFatal(Texts.FilePackageFragmentInstaller_MissingDirectory(sourceDirectory), sourceDirectoryAttribute);
continue;
}
string targetDirectory = PathUtil.Resolve(targetDirectoryAttribute.Value);
if (deleteTargetDirectory)
{
if (C1Directory.Exists(targetDirectory))
{
_directoriesToDelete.Add(targetDirectory);
}
}
foreach (string sourceFilename in this.InstallerContext.ZipFileSystem.GetFilenames(sourceDirectory))
{
string resolvedSourceFilename = sourceFilename.Remove(0, sourceDirectory.Length);
if (resolvedSourceFilename.StartsWith("/"))
{
resolvedSourceFilename = resolvedSourceFilename.Remove(0, 1);
}
string targetFilename = Path.Combine(targetDirectory, resolvedSourceFilename);
if (C1File.Exists(targetFilename) && !deleteTargetDirectory && !allowOverwrite)
{
validationResult.AddFatal(Texts.FilePackageFragmentInstaller_FileExists(targetFilename), targetDirectoryAttribute);
continue;
}
var fileToCopy = new FileToCopy
{
SourceFilename = sourceFilename,
TargetRelativeFilePath = Path.Combine(targetDirectoryAttribute.Value, resolvedSourceFilename),
TargetFilePath = targetFilename,
Overwrite = allowOverwrite
};
_filesToCopy.Add(fileToCopy);
}
}
}
if (validationResult.Count > 0)
{
_filesToCopy = null;
_directoriesToDelete = null;
}
return(validationResult);
}
private IList <PackageFragmentValidationResult> LoadPackageFragmentInstallers(XElement packageFragmentInstallersElement)
{
var result = new List <PackageFragmentValidationResult>();
XName packageInstallerXName = XmlUtils.GetXName(PackageSystemSettings.XmlNamespace, PackageSystemSettings.PackageFragmentInstallersAddElementName);
foreach (XElement element in packageFragmentInstallersElement.Elements(packageInstallerXName))
{
XAttribute installerTypeAttribute = element.Attribute(PackageSystemSettings.InstallerTypeAttributeName);
if (installerTypeAttribute == null)
{
result.AddFatal($"Missing attribute '{PackageSystemSettings.InstallerTypeAttributeName}'", element);
continue;
}
Type installerType = TypeManager.TryGetType(installerTypeAttribute.Value);
if (installerType == null)
{
result.AddFatal($"Could not find install fragment type '{installerTypeAttribute.Value}'", installerTypeAttribute);
continue;
}
IPackageFragmentInstaller packageFragmentInstaller;
try
{
packageFragmentInstaller = Activator.CreateInstance(installerType) as IPackageFragmentInstaller;
}
catch (Exception ex)
{
result.AddFatal(ex);
continue;
}
if (packageFragmentInstaller == null)
{
result.AddFatal($"The type '{installerTypeAttribute.Value}' does not implement {typeof (IPackageFragmentInstaller)}", installerTypeAttribute);
continue;
}
Type uninstallerType = null;
if (this.CanBeUninstalled)
{
XAttribute uninstallerTypeAttribute = element.Attribute(PackageSystemSettings.UninstallerTypeAttributeName);
if (uninstallerTypeAttribute == null)
{
result.AddFatal($"Missing attribute '{PackageSystemSettings.UninstallerTypeAttributeName}'", element);
continue;
}
uninstallerType = TypeManager.TryGetType(uninstallerTypeAttribute.Value);
if (uninstallerType == null)
{
result.AddFatal($"Could not find uninstall fragment type '{uninstallerTypeAttribute.Value}'", uninstallerTypeAttribute);
continue;
}
IPackageFragmentUninstaller packageFragmentUninstaller;
try
{
packageFragmentUninstaller = Activator.CreateInstance(uninstallerType) as IPackageFragmentUninstaller;
}
catch (Exception ex)
{
result.AddFatal(ex);
continue;
}
if (packageFragmentUninstaller == null)
{
result.AddFatal($"The type '{uninstallerTypeAttribute.Value}' does not implement {typeof (IPackageFragmentUninstaller)}", uninstallerTypeAttribute);
continue;
}
}
try
{
packageFragmentInstaller.Initialize(_packageInstallerContex, element.Descendants(), element);
}
catch (Exception ex)
{
result.AddFatal(ex);
continue;
}
_packageFramentInstallers.Add(packageFragmentInstaller, uninstallerType);
}
return(result);
}
/// <exclude />
public override IEnumerable<PackageFragmentValidationResult> Validate()
{
var validationResult = new List<PackageFragmentValidationResult>();
if (this.Configuration.Count(f => f.Name == "Locales") > 1)
{
validationResult.AddFatal(Texts.PackageFragmentInstaller_OnlyOneElementAllowed("Locales"));
return validationResult;
}
XElement areasElement = this.Configuration.SingleOrDefault(f => f.Name == "Locales");
_localesToInstall = new List<Tuple<CultureInfo, string, bool>>();
if (areasElement != null)
{
foreach (XElement localeElement in areasElement.Elements("Locale"))
{
XAttribute nameAttribute = localeElement.Attribute("name");
XAttribute urlMappingNameAttribute = localeElement.Attribute("urlMappingName");
XAttribute defaultAttribute = localeElement.Attribute("default");
if (nameAttribute == null)
{
// Missing attribute
validationResult.AddFatal(Texts.PackageFragmentInstaller_MissingAttribute("name"), localeElement);
continue;
}
CultureInfo cultureInfo;
try
{
cultureInfo = CultureInfo.CreateSpecificCulture(nameAttribute.Value);
}
catch
{
// Name error
validationResult.AddFatal(Texts.PackageFragmentInstaller_MissingAttribute("name"), nameAttribute);
continue;
}
if (LocalizationFacade.IsLocaleInstalled(cultureInfo))
{
continue; // Skip it, it is installed
}
if (_localesToInstall.Any(f => f.Item1.Equals(cultureInfo)))
{
// Already installed or going to be installed
validationResult.AddFatal(Texts.PackageFragmentInstaller_MissingAttribute("name"), nameAttribute);
continue;
}
string urlMappingName = cultureInfo.Name;
if (urlMappingNameAttribute != null)
{
urlMappingName = urlMappingNameAttribute.Value;
}
if (LocalizationFacade.IsUrlMappingNameInUse(urlMappingName) || _localesToInstall.Any(f => f.Item2 == urlMappingName))
{
// Url mapping name already used or going to be used
validationResult.AddFatal(Texts.PackageFragmentInstaller_MissingAttribute("urlMappingName"), urlMappingNameAttribute);
continue;
}
bool isDefault = false;
if (defaultAttribute != null)
{
if (!defaultAttribute.TryGetBoolValue(out isDefault))
{
// Wrong attribute value
validationResult.AddFatal(Texts.PackageFragmentInstaller_MissingAttribute("default"), defaultAttribute);
continue;
}
}
if (isDefault && _localesToInstall.Any(f => f.Item3))
{
// More than one is specified as default
validationResult.AddFatal(Texts.PackageFragmentInstaller_MissingAttribute("default"), defaultAttribute);
continue;
}
_localesToInstall.Add(new Tuple<CultureInfo, string, bool>(cultureInfo, urlMappingName, isDefault));
this.InstallerContext.AddPendingLocale(cultureInfo);
}
}
if (validationResult.Count > 0)
{
_localesToInstall = null;
}
return validationResult;
}
/// <exclude />
public override IEnumerable<PackageFragmentValidationResult> Validate()
{
_xslTransformations = new List<XslTransformation>();
var validationResult = new List<PackageFragmentValidationResult>();
var filesElement = this.ConfigurationParent.GetSingleConfigurationElement("XslFiles", validationResult, false);
if (filesElement == null)
{
return validationResult;
}
foreach (XElement fileElement in filesElement.GetConfigurationElements("XslFile", validationResult))
{
XAttribute pathXMLAttribute = fileElement.Attribute(TargetXmlAttributeName);
XAttribute inputXMLAttribute = fileElement.Attribute(InputXmlAttributeName);
XAttribute outputXMLAttribute = fileElement.Attribute(OutputXmlAttributeName);
XAttribute pathXSLAttribute = fileElement.Attribute(TargetXslAttributeName);
XAttribute installXSLAttribute = fileElement.Attribute(InstallXslAttributeName);
XAttribute uninstallXSLAttribute = fileElement.Attribute(UninstallXslAttributeName);
XAttribute overrideReadOnlyAttribute = fileElement.Attribute(OverrideReadOnlyAttributeName);
XAttribute skipIfNotExistAttribute = fileElement.Attribute(SkipIfNotExistAttributeName);
bool skipIfNotExist = skipIfNotExistAttribute != null && skipIfNotExistAttribute.Value.ToLower() == "true";
if (pathXSLAttribute == null && installXSLAttribute == null)
{
validationResult.AddFatal(Texts.PackageFragmentInstaller_MissingAttribute(TargetXmlAttributeName), fileElement);
continue;
}
if (outputXMLAttribute != null && uninstallXSLAttribute != null)
{
validationResult.AddFatal("Xsl installer does not suppurt simultaneous usage of attributes '{0}' and '{1}'"
.FormatWith(OutputXmlAttributeName, UninstallXslAttributeName), fileElement);
continue;
}
string xslFilePath = (pathXSLAttribute ?? installXSLAttribute).Value;
XslTransformation xslFile;
if (inputXMLAttribute != null)
{
if (outputXMLAttribute == null)
{
validationResult.AddFatal(Texts.PackageFragmentInstaller_MissingAttribute("outputFilename"), fileElement);
continue;
}
xslFile = new XslTransformation
{
XslPath = xslFilePath,
InputXmlPath = inputXMLAttribute.Value,
OutputXmlPath = outputXMLAttribute.Value
};
}
else
{
if (pathXMLAttribute == null)
{
validationResult.AddFatal(Texts.PackageFragmentInstaller_MissingAttribute(TargetXmlAttributeName), fileElement);
continue;
}
string pathToXmlFile = pathXMLAttribute.Value;
xslFile = new XslTransformation
{
XslPath = xslFilePath,
// UninstallXslPath = uninstallXSLAttribute != null ? uninstallXSLAttribute.Value : null,
InputXmlPath = pathToXmlFile,
OutputXmlPath = pathToXmlFile
};
}
if (!C1File.Exists(PathUtil.Resolve(xslFile.InputXmlPath)))
{
if (skipIfNotExist) continue;
validationResult.AddFatal(Texts.FileXslTransformationPackageFragmentInstaller_FileNotFound(xslFile.InputXmlPath), fileElement);
continue;
}
string outputXmlFullPath = PathUtil.Resolve(xslFile.OutputXmlPath);
if (C1File.Exists(outputXmlFullPath) && (C1File.GetAttributes(outputXmlFullPath) & FileAttributes.ReadOnly) > 0)
{
if (overrideReadOnlyAttribute == null || overrideReadOnlyAttribute.Value != "true")
{
validationResult.AddFatal(Texts.FileXslTransformationPackageFragmentInstaller_FileReadOnly(xslFile.OutputXmlPath), fileElement);
continue;
}
FileUtils.RemoveReadOnly(outputXmlFullPath);
Log.LogWarning(LogTitle, Texts.FileXslTransformationPackageFragmentInstaller_FileReadOnlyOverride(xslFile.OutputXmlPath));
}
if (!PathUtil.WritePermissionGranted(outputXmlFullPath))
{
validationResult.AddFatal(Texts.NotEnoughNtfsPermissions(xslFile.OutputXmlPath), fileElement);
continue;
}
_xslTransformations.Add(xslFile);
}
if (validationResult.Count > 0)
{
_xslTransformations = null;
}
return validationResult;
}
/// <exclude />
public override IEnumerable <PackageFragmentValidationResult> Validate()
{
_xslTransformations = new List <XslTransformation>();
var validationResult = new List <PackageFragmentValidationResult>();
var filesElement = this.ConfigurationParent.GetSingleConfigurationElement("XslFiles", validationResult, false);
if (filesElement == null)
{
return(validationResult);
}
foreach (XElement fileElement in filesElement.GetConfigurationElements("XslFile", validationResult))
{
XAttribute pathXMLAttribute = fileElement.Attribute(TargetXmlAttributeName);
XAttribute inputXMLAttribute = fileElement.Attribute(InputXmlAttributeName);
XAttribute outputXMLAttribute = fileElement.Attribute(OutputXmlAttributeName);
XAttribute pathXSLAttribute = fileElement.Attribute(TargetXslAttributeName);
XAttribute installXSLAttribute = fileElement.Attribute(InstallXslAttributeName);
XAttribute uninstallXSLAttribute = fileElement.Attribute(UninstallXslAttributeName);
XAttribute overrideReadOnlyAttribute = fileElement.Attribute(OverrideReadOnlyAttributeName);
XAttribute skipIfNotExistAttribute = fileElement.Attribute(SkipIfNotExistAttributeName);
bool skipIfNotExist = skipIfNotExistAttribute != null && skipIfNotExistAttribute.Value.ToLower() == "true";
if (pathXSLAttribute == null && installXSLAttribute == null)
{
validationResult.AddFatal(Texts.PackageFragmentInstaller_MissingAttribute(TargetXmlAttributeName), fileElement);
continue;
}
if (outputXMLAttribute != null && uninstallXSLAttribute != null)
{
validationResult.AddFatal("Xsl installer does not suppurt simultaneous usage of attributes '{0}' and '{1}'"
.FormatWith(OutputXmlAttributeName, UninstallXslAttributeName), fileElement);
continue;
}
string xslFilePath = (pathXSLAttribute ?? installXSLAttribute).Value;
XslTransformation xslFile;
if (inputXMLAttribute != null)
{
if (outputXMLAttribute == null)
{
validationResult.AddFatal(Texts.PackageFragmentInstaller_MissingAttribute("outputFilename"), fileElement);
continue;
}
xslFile = new XslTransformation
{
XslPath = xslFilePath,
InputXmlPath = inputXMLAttribute.Value,
OutputXmlPath = outputXMLAttribute.Value
};
}
else
{
if (pathXMLAttribute == null)
{
validationResult.AddFatal(Texts.PackageFragmentInstaller_MissingAttribute(TargetXmlAttributeName), fileElement);
continue;
}
string pathToXmlFile = pathXMLAttribute.Value;
xslFile = new XslTransformation
{
XslPath = xslFilePath,
// UninstallXslPath = uninstallXSLAttribute != null ? uninstallXSLAttribute.Value : null,
InputXmlPath = pathToXmlFile,
OutputXmlPath = pathToXmlFile
};
}
if (!C1File.Exists(PathUtil.Resolve(xslFile.InputXmlPath)))
{
if (skipIfNotExist)
{
continue;
}
validationResult.AddFatal(Texts.FileXslTransformationPackageFragmentInstaller_FileNotFound(xslFile.InputXmlPath), fileElement);
continue;
}
string outputXmlFullPath = PathUtil.Resolve(xslFile.OutputXmlPath);
if (C1File.Exists(outputXmlFullPath) && (C1File.GetAttributes(outputXmlFullPath) & FileAttributes.ReadOnly) > 0)
{
if (overrideReadOnlyAttribute == null || overrideReadOnlyAttribute.Value != "true")
{
validationResult.AddFatal(Texts.FileXslTransformationPackageFragmentInstaller_FileReadOnly(xslFile.OutputXmlPath), fileElement);
continue;
}
FileUtils.RemoveReadOnly(outputXmlFullPath);
Log.LogWarning(LogTitle, Texts.FileXslTransformationPackageFragmentInstaller_FileReadOnlyOverride(xslFile.OutputXmlPath));
}
if (!PathUtil.WritePermissionGranted(outputXmlFullPath))
{
validationResult.AddFatal(Texts.NotEnoughNtfsPermissions(xslFile.OutputXmlPath), fileElement);
continue;
}
_xslTransformations.Add(xslFile);
}
if (validationResult.Count > 0)
{
_xslTransformations = null;
}
return(validationResult);
}
/// <exclude />
public override IEnumerable <PackageFragmentValidationResult> Validate()
{
var validationResult = new List <PackageFragmentValidationResult>();
if (this.Configuration.Count(f => f.Name == "Locales") > 1)
{
validationResult.AddFatal(Texts.PackageFragmentInstaller_OnlyOneElementAllowed("Locales"));
return(validationResult);
}
XElement areasElement = this.Configuration.SingleOrDefault(f => f.Name == "Locales");
_localesToInstall = new List <Tuple <CultureInfo, string, bool> >();
if (areasElement != null)
{
foreach (XElement localeElement in areasElement.Elements("Locale"))
{
XAttribute nameAttribute = localeElement.Attribute("name");
XAttribute urlMappingNameAttribute = localeElement.Attribute("urlMappingName");
XAttribute defaultAttribute = localeElement.Attribute("default");
if (nameAttribute == null)
{
// Missing attribute
validationResult.AddFatal(Texts.PackageFragmentInstaller_MissingAttribute("name"), localeElement);
continue;
}
CultureInfo cultureInfo;
try
{
cultureInfo = CultureInfo.CreateSpecificCulture(nameAttribute.Value);
}
catch
{
// Name error
validationResult.AddFatal(Texts.PackageFragmentInstaller_MissingAttribute("name"), nameAttribute);
continue;
}
if (LocalizationFacade.IsLocaleInstalled(cultureInfo))
{
continue; // Skip it, it is installed
}
if (_localesToInstall.Any(f => f.Item1.Equals(cultureInfo)))
{
// Already installed or going to be installed
validationResult.AddFatal(Texts.PackageFragmentInstaller_MissingAttribute("name"), nameAttribute);
continue;
}
string urlMappingName = cultureInfo.Name;
if (urlMappingNameAttribute != null)
{
urlMappingName = urlMappingNameAttribute.Value;
}
if (LocalizationFacade.IsUrlMappingNameInUse(urlMappingName) || _localesToInstall.Any(f => f.Item2 == urlMappingName))
{
// Url mapping name already used or going to be used
validationResult.AddFatal(Texts.PackageFragmentInstaller_MissingAttribute("urlMappingName"), urlMappingNameAttribute);
continue;
}
bool isDefault = false;
if (defaultAttribute != null)
{
if (!defaultAttribute.TryGetBoolValue(out isDefault))
{
// Wrong attribute value
validationResult.AddFatal(Texts.PackageFragmentInstaller_MissingAttribute("default"), defaultAttribute);
continue;
}
}
if (isDefault && _localesToInstall.Any(f => f.Item3))
{
// More than one is specified as default
validationResult.AddFatal(Texts.PackageFragmentInstaller_MissingAttribute("default"), defaultAttribute);
continue;
}
_localesToInstall.Add(new Tuple <CultureInfo, string, bool>(cultureInfo, urlMappingName, isDefault));
this.InstallerContext.AddPendingLocale(cultureInfo);
}
}
if (validationResult.Count > 0)
{
_localesToInstall = null;
}
return(validationResult);
}
/// <exclude />
public override IEnumerable<PackageFragmentValidationResult> Validate()
{
var validationResult = new List<PackageFragmentValidationResult>();
if (this.Configuration.Count(f => f.Name == "Types") > 1)
{
validationResult.AddFatal(GetText("DataTypePackageFragmentInstaller.OnlyOneElement"));
return validationResult;
}
XElement typesElement = this.Configuration.SingleOrDefault(f => f.Name == "Types");
if (typesElement == null)
{
validationResult.AddFatal(GetText("DataTypePackageFragmentInstaller.MissingElement"));
return validationResult;
}
_typesToInstall = new List<DataTypeDescriptor>();
foreach (XElement typeElement in typesElement.Elements("Type"))
{
XAttribute nameAttribute = typeElement.Attribute("name");
if (nameAttribute == null)
{
validationResult.AddFatal(GetText("DataTypePackageFragmentInstaller.MissingAttribute").FormatWith("name"), typeElement);
continue;
}
Type type = TypeManager.TryGetType(nameAttribute.Value);
if (type == null)
{
validationResult.AddFatal(GetText("DataTypePackageFragmentInstaller.TypeNotConfigured").FormatWith(nameAttribute.Value));
}
else if (!typeof(IData).IsAssignableFrom(type))
{
validationResult.AddFatal(GetText("DataTypePackageFragmentInstaller.TypeNotInheriting").FormatWith(type, typeof(IData)));
}
else if (DataFacade.GetAllKnownInterfaces().Contains(type))
{
validationResult.AddFatal(GetText("DataTypePackageFragmentInstaller.TypeExists").FormatWith(type));
}
else
{
DataTypeDescriptor dataTypeDescriptor = null;
try
{
dataTypeDescriptor = DynamicTypeManager.GetDataTypeDescriptor(type);
dataTypeDescriptor.Validate();
}
catch(Exception ex)
{
validationResult.AddFatal(GetText("DataTypePackageFragmentInstaller.InterfaceCodeError").FormatWith(type));
validationResult.AddFatal(ex);
Log.LogError(LogTitle, ex);
}
if (dataTypeDescriptor != null)
{
_typesToInstall.Add(dataTypeDescriptor);
this.InstallerContext.AddPendingDataType(type);
}
}
}
if (validationResult.Count > 0)
{
_typesToInstall = null;
}
return validationResult;
}
private IList<PackageFragmentValidationResult> LoadPackageFragmentInstallers(XElement packageFragmentInstallersElement)
{
var result = new List<PackageFragmentValidationResult>();
XName packageInstallerXName = XmlUtils.GetXName(PackageSystemSettings.XmlNamespace, PackageSystemSettings.PackageFragmentInstallersAddElementName);
foreach (XElement element in packageFragmentInstallersElement.Elements(packageInstallerXName))
{
XAttribute installerTypeAttribute = element.Attribute(PackageSystemSettings.InstallerTypeAttributeName);
if (installerTypeAttribute == null)
{
result.AddFatal(string.Format("Missing attribute '{0}'", PackageSystemSettings.InstallerTypeAttributeName), element);
continue;
}
Type installerType = TypeManager.TryGetType(installerTypeAttribute.Value);
if (installerType == null)
{
result.AddFatal(string.Format("Could not find install fragment type '{0}'", installerTypeAttribute.Value), installerTypeAttribute);
continue;
}
IPackageFragmentInstaller packageFragmentInstaller;
try
{
packageFragmentInstaller = Activator.CreateInstance(installerType) as IPackageFragmentInstaller;
}
catch (Exception ex)
{
result.AddFatal(ex);
continue;
}
if (packageFragmentInstaller == null)
{
result.AddFatal(string.Format("The type '{0}' does not implement {1}", installerTypeAttribute.Value, typeof(IPackageFragmentInstaller)), installerTypeAttribute);
continue;
}
Type uninstallerType = null;
if (this.CanBeUninstalled)
{
XAttribute uninstallerTypeAttribute = element.Attribute(PackageSystemSettings.UninstallerTypeAttributeName);
if (uninstallerTypeAttribute == null)
{
result.AddFatal(string.Format("Missing attribute '{0}'", PackageSystemSettings.UninstallerTypeAttributeName), element);
continue;
}
uninstallerType = TypeManager.TryGetType(uninstallerTypeAttribute.Value);
if (uninstallerType == null)
{
result.AddFatal(string.Format("Could not find uninstall fragment type '{0}'", uninstallerTypeAttribute.Value), uninstallerTypeAttribute);
continue;
}
IPackageFragmentUninstaller packageFragmentUninstaller;
try
{
packageFragmentUninstaller = Activator.CreateInstance(uninstallerType) as IPackageFragmentUninstaller;
}
catch (Exception ex)
{
result.AddFatal(ex);
continue;
}
if (packageFragmentUninstaller == null)
{
result.AddFatal(string.Format("The type '{0}' does not implement {1}", uninstallerTypeAttribute.Value, typeof(IPackageFragmentUninstaller)), uninstallerTypeAttribute);
continue;
}
}
try
{
packageFragmentInstaller.Initialize(_packageInstallerContex, element.Descendants(), element);
}
catch (Exception ex)
{
result.AddFatal(ex);
continue;
}
_packageFramentInstallers.Add(packageFragmentInstaller, uninstallerType);
}
return result;
}
private IEnumerable<PackageFragmentValidationResult> LoadPackageFragmentInstallerBinaries(XElement packageFragmentInstallerBinariesElement)
{
var binaryElements = packageFragmentInstallerBinariesElement.Elements(XmlUtils.GetXName(PackageSystemSettings.XmlNamespace,
PackageSystemSettings.PackageFragmentInstallerBinariesAddElementName)).ToList();
if (!binaryElements.Any())
{
return new PackageFragmentValidationResult[0];
}
string binariesDirectory = Path.Combine(this.PackageInstallDirectory, PackageSystemSettings.BinariesDirectoryName);
if (!C1Directory.Exists(binariesDirectory))
{
C1Directory.CreateDirectory(binariesDirectory);
}
var result = new List<PackageFragmentValidationResult>();
foreach (XElement element in binaryElements)
{
XAttribute pathAttribute = element.Attribute(PackageSystemSettings.PathAttributeName);
string sourceFilename = pathAttribute.Value;
string targetFilename = Path.Combine(binariesDirectory, Path.GetFileName(sourceFilename));
ZipFileSystem zipFileSystem = new ZipFileSystem(this.ZipFilename);
if (!zipFileSystem.ContainsFile(sourceFilename))
{
result.AddFatal(string.Format("The file '{0}' is missing from the zipfile", sourceFilename));
continue;
}
// Extracting dll to package temp folder
if (C1File.Exists(targetFilename))
{
bool success = false;
try
{
FileUtils.Delete(targetFilename);
success = true;
}
catch(UnauthorizedAccessException) {}
if(!success)
{
result.AddFatal("Access denied to file '{0}'".FormatWith(targetFilename));
continue;
}
}
zipFileSystem.WriteFileToDisk(sourceFilename, targetFilename);
string newTargetFilename = Path.Combine(this.TempDirectory, Path.GetFileName(targetFilename));
C1File.Copy(targetFilename, newTargetFilename);
Log.LogVerbose("PackageInstaller", "Loading package uninstaller fragment assembly '{0}'", newTargetFilename);
PackageAssemblyHandler.AddAssembly(newTargetFilename);
}
return result;
}
/// <exclude />
public override IEnumerable <PackageFragmentValidationResult> Validate()
{
var validationResult = new List <PackageFragmentValidationResult>();
var foreignKeyReferences = new List <string>();
if (this.Configuration.Count(f => f.Name == "Types") > 1)
{
validationResult.AddFatal(Texts.DynamicDataTypePackageFragmentInstaller_OnlyOneElement);
return(validationResult);
}
XElement typesElement = this.Configuration.SingleOrDefault(f => f.Name == "Types");
if (typesElement == null)
{
validationResult.AddFatal(Texts.DynamicDataTypePackageFragmentInstaller_MissingElement);
return(validationResult);
}
_dataTypeDescriptors = new List <DataTypeDescriptor>();
foreach (XElement typeElement in typesElement.Elements("Type"))
{
XElement serializedDataTypeDescriptor;
XAttribute fileAttribute = typeElement.Attribute("dataTypeDescriptorFile");
if (fileAttribute != null)
{
string relativeFilePath = (string)fileAttribute;
string markup;
using (var stream = this.InstallerContext.ZipFileSystem.GetFileStream(relativeFilePath))
using (var reader = new StreamReader(stream))
{
markup = reader.ReadToEnd();
}
serializedDataTypeDescriptor = XElement.Parse(markup);
}
else
{
var dataTypeDescriptorAttribute = typeElement.Attribute("dataTypeDescriptor");
if (dataTypeDescriptorAttribute == null)
{
validationResult.AddFatal(Texts.DataTypePackageFragmentInstaller_MissingAttribute("dataTypeDescriptor"), typeElement);
continue;
}
try
{
serializedDataTypeDescriptor = XElement.Parse(dataTypeDescriptorAttribute.Value);
}
catch (Exception)
{
validationResult.AddFatal(Texts.DynamicDataTypePackageFragmentInstaller_DataTypeDescriptorParseError, dataTypeDescriptorAttribute);
continue;
}
}
DataTypeDescriptor dataTypeDescriptor;
try
{
bool inheritedFieldsIncluded = serializedDataTypeDescriptor.Descendants().Any(e => e.Attributes("inherited").Any(a => (string)a == "true"));
dataTypeDescriptor = DataTypeDescriptor.FromXml(serializedDataTypeDescriptor, inheritedFieldsIncluded);
}
catch (Exception e)
{
validationResult.AddFatal(Texts.DynamicDataTypePackageFragmentInstaller_DataTypeDescriptorDeserializeError(e.Message));
continue;
}
Type type = TypeManager.TryGetType(dataTypeDescriptor.TypeManagerTypeName);
if (type != null && DataFacade.GetAllKnownInterfaces().Contains(type))
{
validationResult.AddFatal(Texts.DynamicDataTypePackageFragmentInstaller_TypeExists(type));
}
if (dataTypeDescriptor.SuperInterfaces.Any(f => f.Name == nameof(IVersioned)))
{
if (dataTypeDescriptor.Fields.All(f => f.Name != nameof(IVersioned.VersionId)))
{
dataTypeDescriptor.Fields.Add(new DataFieldDescriptor(Guid.NewGuid(), nameof(IVersioned.VersionId), StoreFieldType.Guid, typeof(Guid), true));
}
}
foreach (var field in dataTypeDescriptor.Fields)
{
if (!field.ForeignKeyReferenceTypeName.IsNullOrEmpty())
{
foreignKeyReferences.Add(field.ForeignKeyReferenceTypeName);
}
}
_dataTypeDescriptors.Add(dataTypeDescriptor);
this.InstallerContext.AddPendingDataTypeDescritpor(dataTypeDescriptor.TypeManagerTypeName, dataTypeDescriptor);
}
foreach (string foreignKeyTypeName in foreignKeyReferences)
{
if (!TypeManager.HasTypeWithName(foreignKeyTypeName) &&
!_dataTypeDescriptors.Any(descriptor => descriptor.TypeManagerTypeName == foreignKeyTypeName))
{
validationResult.AddFatal(Texts.DynamicDataTypePackageFragmentInstaller_MissingReferencedType(foreignKeyTypeName));
}
}
if (validationResult.Count > 0)
{
_dataTypeDescriptors = null;
}
return(validationResult);
}
/// <exclude />
public override IEnumerable <PackageFragmentValidationResult> Validate()
{
var validationResult = new List <PackageFragmentValidationResult>();
if (this.Configuration.Count(f => f.Name == "Files") > 1)
{
validationResult.AddFatal(Texts.FilePackageFragmentUninstaller_OnlyOneFilesElement, ConfigurationParent);
return(validationResult);
}
XElement filesElement = this.Configuration.SingleOrDefault(f => f.Name == "Files");
_filesToDelete = new List <string>();
_filesToCopy = new List <FileToCopy>();
if (filesElement != null)
{
foreach (XElement fileElement in filesElement.Elements("File").Reverse())
{
XAttribute filenameAttribute = fileElement.Attribute("filename");
if (filenameAttribute == null)
{
validationResult.AddFatal(Texts.FilePackageFragmentInstaller_MissingAttribute("filename"), fileElement);
continue;
}
string relativeFilePath = filenameAttribute.Value;
string filePath = PathUtil.Resolve(relativeFilePath);
string backupFile = (string)fileElement.Attribute("backupFile");
if (backupFile != null)
{
var backupFilePath = Path.Combine(UninstallerContext.PackageDirectory, "FileBackup", backupFile);
if (!C1File.Exists(backupFilePath))
{
validationResult.AddFatal("Missing backup file '{0}'".FormatWith(backupFilePath), fileElement);
continue;
}
_filesToCopy.Add(new FileToCopy
{
BackupFilePath = backupFilePath,
FilePath = filePath,
RelativeFilePath = relativeFilePath
});
}
else
{
_filesToDelete.Add(filePath);
}
}
}
if (validationResult.Count > 0)
{
_filesToDelete = null;
_filesToCopy = null;
}
return(validationResult);
}
internal static void ValidateXslt(List <PackageFragmentValidationResult> validationResults, Func <XElement> elementProvider, string elementName, Func <XAttribute> xsltPathAttributeProvider, Func <string> xsltFilePathProvider, IZipFileSystem zipFileSystem, bool validateResultingConfigurationFile)
{
if (elementProvider() == null)
{
validationResults.AddFatal(
GetResourceString("ConfigurationTransformationPackageFragmentInstaller.MissingElement")
.FormatWith(elementName));
return;
}
string xslFilePath = xsltFilePathProvider();
if (xslFilePath == null)
{
validationResults.AddFatal(
GetResourceString("ConfigurationTransformationPackageFragmentInstaller.MissingAttribute")
.FormatWith(_xsltFilePathAttributeName), elementProvider());
return;
}
if (zipFileSystem.ContainsFile(xslFilePath) == false)
{
validationResults.AddFatal(
GetResourceString("ConfigurationTransformationPackageFragmentInstaller.PathDoesNotExist")
.FormatWith(xslFilePath), xsltPathAttributeProvider());
return;
}
if (!PathUtil.WritePermissionGranted(ConfigurationServices.FileConfigurationSourcePath))
{
validationResults.AddFatal(
GetResourceString("NotEnoughNtfsPermissions")
.FormatWith(ConfigurationServices.FileConfigurationSourcePath));
return;
}
using (Stream xsltFileStream = zipFileSystem.GetFileStream(xslFilePath))
{
using (TextReader xsltTextReader = new C1StreamReader(xsltFileStream))
{
XDocument xslt = null;
try
{
xslt = XDocument.Load(xsltTextReader);
}
catch (Exception ex)
{
validationResults.AddFatal(
GetResourceString("ConfigurationTransformationPackageFragmentInstaller.UnableToParsXslt")
.FormatWith(xslFilePath, ex.Message), xsltPathAttributeProvider());
}
if (xslt != null && validateResultingConfigurationFile)
{
try
{
ConfigurationServices.TransformConfiguration(xslt, true);
}
//catch (ConfigurationException ex)
//{
// validationResults.AddFatal(
// GetResourceString("ConfigurationTransformationPackageFragmentInstaller.XsltWillGeneratedInvalid")
// .FormatWith(xsltFilePathProvider(), ex.Message), xsltPathAttributeProvider());
//}
catch (Exception ex)
{
validationResults.AddFatal(
GetResourceString("ConfigurationTransformationPackageFragmentInstaller.XsltWillGeneratedInvalid")
.FormatWith(xslFilePath, ex.Message), xsltPathAttributeProvider());
}
}
}
}
}
private IEnumerable <PackageFragmentValidationResult> LoadPackageFragmentInstallerBinaries(XElement packageFragmentInstallerBinariesElement)
{
var binaryElements = packageFragmentInstallerBinariesElement.Elements(XmlUtils.GetXName(PackageSystemSettings.XmlNamespace,
PackageSystemSettings.PackageFragmentInstallerBinariesAddElementName)).ToList();
if (!binaryElements.Any())
{
return(new PackageFragmentValidationResult[0]);
}
string binariesDirectory = Path.Combine(this.PackageInstallDirectory, PackageSystemSettings.BinariesDirectoryName);
if (!C1Directory.Exists(binariesDirectory))
{
C1Directory.CreateDirectory(binariesDirectory);
}
var result = new List <PackageFragmentValidationResult>();
foreach (XElement element in binaryElements)
{
XAttribute pathAttribute = element.Attribute(PackageSystemSettings.PathAttributeName);
string sourceFilename = pathAttribute.Value;
string targetFilename = Path.Combine(binariesDirectory, Path.GetFileName(sourceFilename));
ZipFileSystem zipFileSystem = new ZipFileSystem(this.ZipFilename);
if (!zipFileSystem.ContainsFile(sourceFilename))
{
result.AddFatal($"The file '{sourceFilename}' is missing from the zip file");
continue;
}
// Extracting dll to package temp folder
if (C1File.Exists(targetFilename))
{
bool success = false;
try
{
FileUtils.Delete(targetFilename);
success = true;
}
catch (UnauthorizedAccessException) {}
if (!success)
{
result.AddFatal($"Access denied to file '{targetFilename}'");
continue;
}
}
zipFileSystem.WriteFileToDisk(sourceFilename, targetFilename);
string newTargetFilename = Path.Combine(this.TempDirectory, Path.GetFileName(targetFilename));
C1File.Copy(targetFilename, newTargetFilename);
Log.LogVerbose("PackageInstaller", "Loading package uninstaller fragment assembly '{0}'", newTargetFilename);
PackageAssemblyHandler.AddAssembly(newTargetFilename);
}
return(result);
}
/// <exclude />
public override IEnumerable<PackageFragmentValidationResult> Validate()
{
var validationResult = new List<PackageFragmentValidationResult>();
var foreignKeyReferences = new List<string>();
if (this.Configuration.Count(f => f.Name == "Types") > 1)
{
validationResult.AddFatal(GetText("DynamicDataTypePackageFragmentInstaller.OnlyOneElement"));
return validationResult;
}
XElement typesElement = this.Configuration.SingleOrDefault(f => f.Name == "Types");
if (typesElement == null)
{
validationResult.AddFatal(GetText("DynamicDataTypePackageFragmentInstaller.MissingElement"));
return validationResult;
}
_dataTypeDescriptors = new List<DataTypeDescriptor>();
foreach (XElement typeElement in typesElement.Elements("Type"))
{
XAttribute dataTypeDescriptorAttribute = typeElement.Attribute("dataTypeDescriptor");
if (dataTypeDescriptorAttribute == null)
{
validationResult.AddFatal(GetText("DataTypePackageFragmentInstaller.MissingAttribute").FormatWith("dataTypeDescriptor"), typeElement);
continue;
}
XElement serializedDataTypeDescriptor;
try
{
serializedDataTypeDescriptor = XElement.Parse(dataTypeDescriptorAttribute.Value);
}
catch (Exception)
{
validationResult.AddFatal(GetText("DynamicDataTypePackageFragmentInstaller.DataTypeDescriptorParseError"), dataTypeDescriptorAttribute);
continue;
}
DataTypeDescriptor dataTypeDescriptor;
try
{
bool inheritedFieldsIncluded = serializedDataTypeDescriptor.Descendants().Any(e => e.Attributes("inherited").Any(a => (string) a == "true"));
dataTypeDescriptor = DataTypeDescriptor.FromXml(serializedDataTypeDescriptor, inheritedFieldsIncluded);
}
catch (Exception e)
{
validationResult.AddFatal(GetText("DynamicDataTypePackageFragmentInstaller.DataTypeDescriptorDeserializeError").FormatWith(e.Message));
continue;
}
Type type = TypeManager.TryGetType(dataTypeDescriptor.TypeManagerTypeName);
if ((type != null) && (DataFacade.GetAllKnownInterfaces().Contains(type)))
{
validationResult.AddFatal(GetText("DynamicDataTypePackageFragmentInstaller.TypeExists").FormatWith(type));
}
if (dataTypeDescriptor.SuperInterfaces.Any(f=>f.Name==nameof(IVersioned)))
{
if (dataTypeDescriptor.Fields.All(f => f.Name != nameof(IVersioned.VersionId)))
{
dataTypeDescriptor.Fields.Add(new DataFieldDescriptor(Guid.NewGuid(), nameof(IVersioned.VersionId),StoreFieldType.Guid, typeof(Guid),true ));
}
}
foreach (var field in dataTypeDescriptor.Fields)
{
if(!field.ForeignKeyReferenceTypeName.IsNullOrEmpty())
{
foreignKeyReferences.Add(field.ForeignKeyReferenceTypeName);
}
}
_dataTypeDescriptors.Add(dataTypeDescriptor);
this.InstallerContext.AddPendingDataTypeDescritpor(dataTypeDescriptor.TypeManagerTypeName, dataTypeDescriptor);
}
foreach(string foreignKeyTypeName in foreignKeyReferences)
{
if(!TypeManager.HasTypeWithName(foreignKeyTypeName)
&& !_dataTypeDescriptors.Any(descriptor => descriptor.TypeManagerTypeName == foreignKeyTypeName))
{
validationResult.AddFatal(GetText("DynamicDataTypePackageFragmentInstaller.MissingReferencedType").FormatWith(foreignKeyTypeName));
}
}
if (validationResult.Count > 0)
{
_dataTypeDescriptors = null;
}
return validationResult;
}
/// <exclude/>
public override IEnumerable<PackageFragmentValidationResult> Validate()
{
var validationResult = new List<PackageFragmentValidationResult>();
_contentToAdd = new List<ContentToAdd>();
foreach (var element in this.Configuration)
{
if (element.Name != AppendText_ElementName)
{
validationResult.AddFatal(Texts.PackageFragmentInstaller_IncorrectElement(element.Name.LocalName, AppendText_ElementName), element);
continue;
}
var pathAttr = element.Attribute(TargetXml_AttributeName);
if (pathAttr == null)
{
validationResult.AddFatal(Texts.PackageFragmentInstaller_MissingAttribute(TargetXml_AttributeName), element);
continue;
}
string path = (string)pathAttr;
var actionOnMissingFile = ActionOnMissingFile.Fail;
var whenNotExistsAttr = element.Attribute(WhenNotExist_AttributeName);
if (whenNotExistsAttr != null)
{
actionOnMissingFile = (ActionOnMissingFile) Enum.Parse(typeof (ActionOnMissingFile), whenNotExistsAttr.Value, true);
}
string filePath = PathUtil.Resolve(path);
if (!C1File.Exists(filePath))
{
if (actionOnMissingFile == ActionOnMissingFile.Fail)
{
validationResult.AddFatal(Texts.FileModifyPackageFragmentInstaller_FileDoesNotExist(filePath), pathAttr);
continue;
}
if (actionOnMissingFile == ActionOnMissingFile.Ignore)
{
continue;
}
}
_contentToAdd.Add(new ContentToAdd
{
Path = filePath,
Content = element.Value
});
}
if (validationResult.Any())
{
_contentToAdd = null;
}
return validationResult;
}
/// <exclude/>
public override IEnumerable <PackageFragmentValidationResult> Validate()
{
var validationResult = new List <PackageFragmentValidationResult>();
_contentToAdd = new List <ContentToAdd>();
foreach (var element in this.Configuration)
{
if (element.Name != AppendText_ElementName)
{
validationResult.AddFatal(Texts.PackageFragmentInstaller_IncorrectElement(element.Name.LocalName, AppendText_ElementName), element);
continue;
}
var pathAttr = element.Attribute(TargetXml_AttributeName);
if (pathAttr == null)
{
validationResult.AddFatal(Texts.PackageFragmentInstaller_MissingAttribute(TargetXml_AttributeName), element);
continue;
}
string path = (string)pathAttr;
var actionOnMissingFile = ActionOnMissingFile.Fail;
var whenNotExistsAttr = element.Attribute(WhenNotExist_AttributeName);
if (whenNotExistsAttr != null)
{
actionOnMissingFile = (ActionOnMissingFile)Enum.Parse(typeof(ActionOnMissingFile), whenNotExistsAttr.Value, true);
}
string filePath = PathUtil.Resolve(path);
if (!C1File.Exists(filePath))
{
if (actionOnMissingFile == ActionOnMissingFile.Fail)
{
validationResult.AddFatal(Texts.FileModifyPackageFragmentInstaller_FileDoesNotExist(filePath), pathAttr);
continue;
}
if (actionOnMissingFile == ActionOnMissingFile.Ignore)
{
continue;
}
}
_contentToAdd.Add(new ContentToAdd
{
Path = filePath,
Content = element.Value
});
}
if (validationResult.Any())
{
_contentToAdd = null;
}
return(validationResult);
}
/// <exclude />
public override IEnumerable <PackageFragmentValidationResult> Validate()
{
var validationResult = new List <PackageFragmentValidationResult>();
if (this.Configuration.Count(f => f.Name == "Files") > 1)
{
validationResult.AddFatal(Texts.FilePackageFragmentInstaller_OnlyOneFilesElement,
this.ConfigurationParent);
return(validationResult);
}
XElement filesElement = this.Configuration.SingleOrDefault(f => f.Name == "Files");
_filesToCopy = new List <FileToCopy>();
if (filesElement != null)
{
foreach (XElement fileElement in filesElement.Elements("File"))
{
XAttribute sourceFilenameAttribute = fileElement.Attribute("sourceFilename");
XAttribute targetFilenameAttribute = fileElement.Attribute("targetFilename");
if (sourceFilenameAttribute == null)
{
validationResult.AddFatal(
Texts.FilePackageFragmentInstaller_MissingAttribute("sourceFilename"), fileElement);
continue;
}
if (targetFilenameAttribute == null)
{
validationResult.AddFatal(
Texts.FilePackageFragmentInstaller_MissingAttribute("targetFilename"), fileElement);
continue;
}
XAttribute allowOverwriteAttribute = fileElement.Attribute("allowOverwrite");
XAttribute assemblyLoadAttribute = fileElement.Attribute("assemblyLoad");
XAttribute onlyUpdateAttribute = fileElement.Attribute("onlyUpdate");
XAttribute addAssemblyBindingAttribute = fileElement.Attribute("addAssemblyBinding");
bool allowOverwrite = false;
if (!ParseBoolAttribute(allowOverwriteAttribute, validationResult, ref allowOverwrite))
{
continue;
}
bool loadAssembly = false;
if (!ParseBoolAttribute(assemblyLoadAttribute, validationResult, ref loadAssembly))
{
continue;
}
bool onlyUpdate = false;
if (!ParseBoolAttribute(onlyUpdateAttribute, validationResult, ref onlyUpdate))
{
continue;
}
bool addAssemblyBinding = false;
if (!ParseBoolAttribute(addAssemblyBindingAttribute, validationResult, ref addAssemblyBinding))
{
continue;
}
string sourceFilename = sourceFilenameAttribute.Value;
if (!this.InstallerContext.ZipFileSystem.ContainsFile(sourceFilename))
{
validationResult.AddFatal(Texts.FilePackageFragmentInstaller_MissingFile(sourceFilename),
sourceFilenameAttribute);
continue;
}
if (loadAssembly && onlyUpdate)
{
validationResult.AddFatal(
Texts.FilePackageFragmentInstaller_OnlyUpdateNotAllowedWithLoadAssemlby, onlyUpdateAttribute);
continue;
}
string targetFilename = PathUtil.Resolve(targetFilenameAttribute.Value);
if (C1File.Exists(targetFilename))
{
if (!allowOverwrite && !onlyUpdate)
{
validationResult.AddFatal(Texts.FilePackageFragmentInstaller_FileExists(targetFilename),
targetFilenameAttribute);
continue;
}
if (((C1File.GetAttributes(targetFilename) & FileAttributes.ReadOnly) > 0) && !allowOverwrite)
{
validationResult.AddFatal(Texts.FilePackageFragmentInstaller_FileReadOnly(targetFilename),
targetFilenameAttribute);
continue;
}
}
else if (onlyUpdate)
{
Log.LogVerbose(LogTitle, "Skipping updating of the file '{0}' because it does not exist",
targetFilename);
continue; // Target file does not, so skip this
}
var fileToCopy = new FileToCopy
{
SourceFilename = sourceFilename,
TargetRelativeFilePath = targetFilenameAttribute.Value,
TargetFilePath = targetFilename,
Overwrite = allowOverwrite || onlyUpdate,
AddAssemblyBinding = addAssemblyBinding
};
_filesToCopy.Add(fileToCopy);
if (loadAssembly)
{
string tempFilename = Path.Combine(this.InstallerContext.TempDirectory,
Path.GetFileName(targetFilename));
this.InstallerContext.ZipFileSystem.WriteFileToDisk(sourceFilename, tempFilename);
PackageAssemblyHandler.AddAssembly(tempFilename);
}
}
}
if (validationResult.Count > 0)
{
_filesToCopy = null;
}
return(validationResult);
}
internal static void ValidateXslt(List<PackageFragmentValidationResult> validationResults, Func<XElement> elementProvider, string elementName, Func<XAttribute> xsltPathAttributeProvider, Func<string> xsltFilePathProvider, IZipFileSystem zipFileSystem, bool validateResultingConfigurationFile)
{
if (elementProvider() == null)
{
validationResults.AddFatal(
GetResourceString("ConfigurationTransformationPackageFragmentInstaller.MissingElement")
.FormatWith(elementName));
return;
}
string xslFilePath = xsltFilePathProvider();
if (xslFilePath == null)
{
validationResults.AddFatal(
GetResourceString("ConfigurationTransformationPackageFragmentInstaller.MissingAttribute")
.FormatWith(_xsltFilePathAttributeName), elementProvider());
return;
}
if (zipFileSystem.ContainsFile(xslFilePath) == false)
{
validationResults.AddFatal(
GetResourceString("ConfigurationTransformationPackageFragmentInstaller.PathDoesNotExist")
.FormatWith(xslFilePath), xsltPathAttributeProvider());
return;
}
if(!PathUtil.WritePermissionGranted(ConfigurationServices.FileConfigurationSourcePath))
{
validationResults.AddFatal(
GetResourceString("NotEnoughNtfsPermissions")
.FormatWith(ConfigurationServices.FileConfigurationSourcePath));
return;
}
using (Stream xsltFileStream = zipFileSystem.GetFileStream(xslFilePath))
{
using (TextReader xsltTextReader = new C1StreamReader(xsltFileStream))
{
XDocument xslt = null;
try
{
xslt = XDocument.Load(xsltTextReader);
}
catch (Exception ex)
{
validationResults.AddFatal(
GetResourceString("ConfigurationTransformationPackageFragmentInstaller.UnableToParsXslt")
.FormatWith(xslFilePath, ex.Message), xsltPathAttributeProvider());
}
if (xslt != null && validateResultingConfigurationFile)
{
try
{
ConfigurationServices.TransformConfiguration(xslt, true);
}
//catch (ConfigurationException ex)
//{
// validationResults.AddFatal(
// GetResourceString("ConfigurationTransformationPackageFragmentInstaller.XsltWillGeneratedInvalid")
// .FormatWith(xsltFilePathProvider(), ex.Message), xsltPathAttributeProvider());
//}
catch (Exception ex)
{
validationResults.AddFatal(
GetResourceString("ConfigurationTransformationPackageFragmentInstaller.XsltWillGeneratedInvalid")
.FormatWith(xslFilePath, ex.Message), xsltPathAttributeProvider());
}
}
}
}
}
private static bool ParseBoolAttribute(XAttribute attribute, List<PackageFragmentValidationResult> validationResult,
ref bool resultValue)
{
if (attribute == null) return true;
if (!attribute.TryGetBoolValue(out resultValue))
{
validationResult.AddFatal(Texts.FilePackageFragmentInstaller_WrongAttributeBoolFormat, attribute);
return false;
}
return true;
}
/// <exclude />
public override IEnumerable <PackageFragmentValidationResult> Validate()
{
var validationResult = new List <PackageFragmentValidationResult>();
if (this.Configuration.Count(f => f.Name == "PackageVersions") > 1)
{
validationResult.AddFatal(Texts.PackageVersionBumperFragmentUninstaller_OnlyOneElement, this.ConfigurationParent);
return(validationResult);
}
XElement packageVersionsElement = this.Configuration.SingleOrDefault(f => f.Name == "PackageVersions");
_packagesToBumb = new Dictionary <Guid, string>();
if (packageVersionsElement != null)
{
foreach (XElement packageVersionElement in packageVersionsElement.Elements("PackageVersion"))
{
XAttribute packageIdAttribute = packageVersionElement.Attribute("packageId");
XAttribute newVersionAttribute = packageVersionElement.Attribute("newVersion");
if (packageIdAttribute == null)
{
validationResult.AddFatal(Texts.PackageVersionBumperFragmentUninstaller_MissingAttribute("packageId"), packageVersionElement);
continue;
}
if (newVersionAttribute == null)
{
validationResult.AddFatal(Texts.PackageVersionBumperFragmentUninstaller_MissingAttribute("newVersion"), packageVersionElement);
continue;
}
Guid packageId;
if (!packageIdAttribute.TryGetGuidValue(out packageId))
{
validationResult.AddFatal(Texts.PackageVersionBumperFragmentUninstaller_WrongAttributeGuidFormat, packageIdAttribute);
continue;
}
if (_packagesToBumb.ContainsKey(packageId))
{
validationResult.AddFatal(Texts.PackageVersionBumperFragmentUninstaller_PackageIdDuplicate(packageId), packageIdAttribute);
continue;
}
Version version;
try
{
version = new Version(newVersionAttribute.Value);
}
catch
{
validationResult.AddFatal(Texts.PackageVersionBumperFragmentUninstaller_WrongAttributeVersionFormat, newVersionAttribute);
continue;
}
_packagesToBumb.Add(packageId, version.ToString());
}
}
if (validationResult.Count > 0)
{
_packagesToBumb = null;
}
return(validationResult);
}
private void CheckForPotentialBrokenReferences(IData data, List<PackageFragmentValidationResult> validationResult,
Type type, DataScopeIdentifier dataScopeIdentifier, CultureInfo locale, DataKeyPropertyCollection dataKeyPropertyCollection)
{
var pagesReferencingPageTypes = new HashSet<string>();
var dataReferencingDataToBeUninstalled = new HashSet<string>();
List<IData> referees = data.GetReferees();
bool addToDelete = true;
foreach (IData referee in referees)
{
if (this.UninstallerContext.IsPendingForDeletionData(referee))
{
continue;
}
addToDelete = false;
if (referee is IPage && data is IPageType)
{
string pathToPage;
using (new DataScope(referee.DataSourceId.PublicationScope, referee.DataSourceId.LocaleScope))
{
pathToPage = GetPathToPage(referee as IPage);
}
if (!pagesReferencingPageTypes.Contains(pathToPage))
{
validationResult.AddFatal(Texts.DataPackageFragmentUninstaller_PageTypeIsReferenced(
data.GetLabel(), pathToPage));
pagesReferencingPageTypes.Add(pathToPage);
}
}
else
{
var refereeType = referee.DataSourceId.InterfaceType;
string label = referee.GetLabel();
string key = label + refereeType.FullName;
if (!dataReferencingDataToBeUninstalled.Contains(key))
{
validationResult.AddFatal(Texts.DataPackageFragmentUninstaller_DataIsReferenced(
data.GetLabel(),
type.FullName,
label,
refereeType.FullName));
dataReferencingDataToBeUninstalled.Add(key);
}
}
}
if (addToDelete)
{
AddDataToDelete(type, dataScopeIdentifier, locale, dataKeyPropertyCollection);
}
}
/// <exclude />
public override IEnumerable <PackageFragmentValidationResult> Validate()
{
var validationResult = new List <PackageFragmentValidationResult>();
if (this.Configuration.Count(f => f.Name == "Files") > 1)
{
validationResult.AddFatal(Texts.FilePackageFragmentUninstaller_OnlyOneFilesElement, ConfigurationParent);
return(validationResult);
}
XElement filesElement = this.Configuration.SingleOrDefault(f => f.Name == "Files");
_filesToDelete = new List <string>();
_filesToCopy = new List <Tuple <string, string> >();
// NOTE: Packages, that were installed on version earlier than C1 1.2 SP3 have absolute file path references, f.e.:
// <File filename="C:\inetpub\docs\Frontend\Composite\Forms\Renderer\CaptchaImageCreator.ashx" />
// <File filename="C:\inetpub\docs\Frontend\Composite\Forms\Renderer\Controls/FormsRender.ascx" />
// <File filename="C:\inetpub\docs\Frontend\Composite\Forms\Renderer\Controls/FormsRender.ascx.cs" />
List <string> absoluteReferences = new List <string>();
if (filesElement != null)
{
foreach (XElement fileElement in filesElement.Elements("File").Reverse())
{
XAttribute filenameAttribute = fileElement.Attribute("filename");
if (filenameAttribute == null)
{
validationResult.AddFatal(Texts.FilePackageFragmentInstaller_MissingAttribute("filename"), fileElement);
continue;
}
string filePath = filenameAttribute.Value;
if (filePath.Contains(":\\"))
{
absoluteReferences.Add(filePath);
continue;
}
filePath = PathUtil.Resolve(filePath);
string backupFile = (string)fileElement.Attribute("backupFile");
if (backupFile != null)
{
var backupFilePath = Path.Combine(UninstallerContext.PackageDirectory, "FileBackup", backupFile);
if (!C1File.Exists(backupFilePath))
{
validationResult.AddFatal("Missing backup file '{0}'".FormatWith(backupFilePath), fileElement);
continue;
}
_filesToCopy.Add(new Tuple <string, string>(backupFilePath, filePath));
}
else
{
_filesToDelete.Add(filePath);
}
}
}
if (absoluteReferences.Count > 0)
{
// Trying to resolve what was the old absolute path.
// To do that the longest common beginning is calculated
string longestCommonBegining;
string firstPath = absoluteReferences[0];
if (absoluteReferences.Count == 1)
{
longestCommonBegining = firstPath;
}
else
{
int shortestPathLength = absoluteReferences.Min(path => path.Length);
int commonStartLength = 0;
for (; commonStartLength < shortestPathLength; commonStartLength++)
{
bool match = true;
char symbol = firstPath[commonStartLength];
for (int i = 1; i < absoluteReferences.Count; i++)
{
if (absoluteReferences[i][commonStartLength] != symbol)
{
match = false;
break;
}
}
if (!match)
{
break;
}
}
longestCommonBegining = firstPath.Substring(0, commonStartLength);
}
longestCommonBegining = longestCommonBegining.Replace('/', '\\');
if (!longestCommonBegining.EndsWith("\\"))
{
longestCommonBegining = longestCommonBegining.Substring(0, longestCommonBegining.LastIndexOf("\\", StringComparison.Ordinal) + 1);
}
string newRoot = PathUtil.BaseDirectory;
if (!newRoot.EndsWith("\\"))
{
newRoot += "\\";
}
// If the site hasn't been moved to another folder, just using the pathes
if (longestCommonBegining.StartsWith(newRoot, StringComparison.OrdinalIgnoreCase))
{
_filesToDelete.AddRange(absoluteReferences);
}
else
{
// If the longest common path looks like C:\inetpub\docs\Frontend\Composite\
// than we will the following pathes as site roots:
//
// C:\inetpub\docs\Frontend\Composite\
// C:\inetpub\docs\Frontend\
// C:\inetpub\docs\
// C:\inetpub\
// C:\
string oldRoot = longestCommonBegining;
bool fileExists = false;
while (!string.IsNullOrEmpty(oldRoot))
{
for (int i = 0; i < absoluteReferences.Count; i++)
{
if (C1File.Exists(ReplaceFolder(absoluteReferences[0], oldRoot, newRoot)))
{
fileExists = true;
break;
}
}
if (fileExists)
{
break;
}
oldRoot = ReducePath(oldRoot);
}
if (!fileExists)
{
// Showing a message if we don't have a match
validationResult.AddFatal(Texts.FilePackageFragmentInstaller_WrongBasePath);
}
else
{
_filesToDelete.AddRange(absoluteReferences.Select(path => ReplaceFolder(path, oldRoot, newRoot)));
}
}
}
if (validationResult.Count > 0)
{
_filesToDelete = null;
_filesToCopy = null;
}
return(validationResult);
}
/// <exclude />
public override IEnumerable<PackageFragmentValidationResult> Validate()
{
var validationResult = new List<PackageFragmentValidationResult>();
if (this.Configuration.Count(f => f.Name == "Files") > 1)
{
validationResult.AddFatal(Texts.FilePackageFragmentUninstaller_OnlyOneFilesElement, ConfigurationParent);
return validationResult;
}
XElement filesElement = this.Configuration.SingleOrDefault(f => f.Name == "Files");
_filesToDelete = new List<string>();
_filesToCopy = new List<Tuple<string, string>>();
// NOTE: Packages, that were installed on version earlier than C1 1.2 SP3 have absolute file path references, f.e.:
// <File filename="C:\inetpub\docs\Frontend\Composite\Forms\Renderer\CaptchaImageCreator.ashx" />
// <File filename="C:\inetpub\docs\Frontend\Composite\Forms\Renderer\Controls/FormsRender.ascx" />
// <File filename="C:\inetpub\docs\Frontend\Composite\Forms\Renderer\Controls/FormsRender.ascx.cs" />
List<string> absoluteReferences = new List<string>();
if (filesElement != null)
{
foreach (XElement fileElement in filesElement.Elements("File").Reverse())
{
XAttribute filenameAttribute = fileElement.Attribute("filename");
if (filenameAttribute == null)
{
validationResult.AddFatal(Texts.FilePackageFragmentInstaller_MissingAttribute("filename"), fileElement);
continue;
}
string filePath = filenameAttribute.Value;
if (filePath.Contains(":\\"))
{
absoluteReferences.Add(filePath);
continue;
}
filePath = PathUtil.Resolve(filePath);
string backupFile = (string) fileElement.Attribute("backupFile");
if (backupFile != null)
{
var backupFilePath = Path.Combine(UninstallerContext.PackageDirectory, "FileBackup", backupFile);
if (!C1File.Exists(backupFilePath))
{
validationResult.AddFatal("Missing backup file '{0}'".FormatWith(backupFilePath), fileElement);
continue;
}
_filesToCopy.Add(new Tuple<string, string>(backupFilePath, filePath));
}
else
{
_filesToDelete.Add(filePath);
}
}
}
if(absoluteReferences.Count > 0)
{
// Trying to resolve what was the old absolute path.
// To do that the longest common beginning is calculated
string longestCommonBegining;
string firstPath = absoluteReferences[0];
if (absoluteReferences.Count == 1)
{
longestCommonBegining = firstPath;
}
else
{
int shortestPathLength = absoluteReferences.Min(path => path.Length);
int commonStartLength = 0;
for (; commonStartLength < shortestPathLength; commonStartLength++)
{
bool match = true;
char symbol = firstPath[commonStartLength];
for (int i = 1; i < absoluteReferences.Count; i++)
{
if (absoluteReferences[i][commonStartLength] != symbol)
{
match = false;
break;
}
}
if (!match) break;
}
longestCommonBegining = firstPath.Substring(0, commonStartLength);
}
longestCommonBegining = longestCommonBegining.Replace('/', '\\');
if(!longestCommonBegining.EndsWith("\\"))
{
longestCommonBegining = longestCommonBegining.Substring(0, longestCommonBegining.LastIndexOf("\\", StringComparison.Ordinal) + 1);
}
string newRoot = PathUtil.BaseDirectory;
if(!newRoot.EndsWith("\\"))
{
newRoot += "\\";
}
// If the site hasn't been moved to another folder, just using the pathes
if (longestCommonBegining.StartsWith(newRoot, StringComparison.OrdinalIgnoreCase))
{
_filesToDelete.AddRange(absoluteReferences);
}
else
{
// If the longest common path looks like C:\inetpub\docs\Frontend\Composite\
// than we will the following pathes as site roots:
//
// C:\inetpub\docs\Frontend\Composite\
// C:\inetpub\docs\Frontend\
// C:\inetpub\docs\
// C:\inetpub\
// C:\
string oldRoot = longestCommonBegining;
bool fileExists = false;
while(!string.IsNullOrEmpty(oldRoot))
{
for(int i=0; i < absoluteReferences.Count; i++)
{
if(C1File.Exists(ReplaceFolder(absoluteReferences[0], oldRoot, newRoot)))
{
fileExists = true;
break;
}
}
if(fileExists) break;
oldRoot = ReducePath(oldRoot);
}
if(!fileExists)
{
// Showing a message if we don't have a match
validationResult.AddFatal(Texts.FilePackageFragmentInstaller_WrongBasePath);
}
else
{
_filesToDelete.AddRange(absoluteReferences.Select(path => ReplaceFolder(path, oldRoot, newRoot)));
}
}
}
if (validationResult.Count > 0)
{
_filesToDelete = null;
_filesToCopy = null;
}
return validationResult;
}
/// <exclude />
public override IEnumerable <PackageFragmentValidationResult> Validate()
{
var validationResult = new List <PackageFragmentValidationResult>();
if (this.Configuration.Count(f => f.Name == "Types") > 1)
{
validationResult.AddFatal(Texts.DataPackageFragmentUninstaller_OnlyOneElement);
return(validationResult);
}
_dataToDelete = new List <DataType>();
XElement typesElement = this.Configuration.SingleOrDefault(f => f.Name == "Types");
if (typesElement == null)
{
return(validationResult);
}
foreach (XElement typeElement in typesElement.Elements("Type").Reverse())
{
XAttribute typeAttribute = typeElement.Attribute("type");
XAttribute dataScopeIdentifierAttribute = typeElement.Attribute("dataScopeIdentifier");
if (typeAttribute == null)
{
validationResult.AddFatal(Texts.DataPackageFragmentUninstaller_MissingAttribute("type"), typeElement);
continue;
}
if (dataScopeIdentifierAttribute == null)
{
validationResult.AddFatal(Texts.DataPackageFragmentUninstaller_MissingAttribute("dataScopeIdentifier"), typeElement);
continue;
}
Type type = TypeManager.TryGetType(typeAttribute.Value);
if (type == null)
{
continue;
}
if (!DataFacade.GetAllInterfaces().Contains(type))
{
continue;
}
DataScopeIdentifier dataScopeIdentifier;
try
{
dataScopeIdentifier = DataScopeIdentifier.Deserialize(dataScopeIdentifierAttribute.Value);
}
catch (Exception)
{
validationResult.AddFatal("Wrong DataScopeIdentifier ({0}) name in the configuration".FormatWith(dataScopeIdentifierAttribute.Value), dataScopeIdentifierAttribute);
continue;
}
foreach (XElement datasElement in typeElement.Elements("Datas").Reverse())
{
CultureInfo locale = null;
XAttribute localeAttribute = datasElement.Attribute("locale");
if (localeAttribute != null)
{
locale = CultureInfo.CreateSpecificCulture(localeAttribute.Value);
}
foreach (XElement keysElement in datasElement.Elements("Keys").Reverse())
{
bool allKeyPropertiesValidated = true;
var dataKeyPropertyCollection = new DataKeyPropertyCollection();
foreach (XElement keyElement in keysElement.Elements("Key"))
{
XAttribute keyNameAttribute = keyElement.Attribute("name");
XAttribute keyValueAttribute = keyElement.Attribute("value");
if (keyNameAttribute == null || keyValueAttribute == null)
{
if (keyNameAttribute == null)
{
validationResult.AddFatal(GetText("DataPackageFragmentUninstaller.MissingAttribute").FormatWith("name"), keyElement);
}
if (keyValueAttribute == null)
{
validationResult.AddFatal(GetText("DataPackageFragmentUninstaller.MissingAttribute").FormatWith("value"), keyElement);
}
allKeyPropertiesValidated = false;
continue;
}
string keyName = keyNameAttribute.Value;
PropertyInfo keyPropertyInfo = type.GetPropertiesRecursively().SingleOrDefault(f => f.Name == keyName);
if (keyPropertyInfo == null)
{
validationResult.AddFatal(GetText("DataPackageFragmentUninstaller.MissingKeyProperty").FormatWith(type, keyName));
allKeyPropertiesValidated = false;
}
else
{
try
{
object keyValue = ValueTypeConverter.Convert(keyValueAttribute.Value, keyPropertyInfo.PropertyType);
dataKeyPropertyCollection.AddKeyProperty(keyName, keyValue);
}
catch (Exception)
{
allKeyPropertiesValidated = false;
validationResult.AddFatal(GetText("DataPackageFragmentUninstaller.DataPackageFragmentUninstaller").FormatWith(keyValueAttribute.Value, keyPropertyInfo.PropertyType));
}
}
}
if (allKeyPropertiesValidated)
{
IData data;
using (new DataScope(dataScopeIdentifier, locale))
{
data = DataFacade.TryGetDataByUniqueKey(type, dataKeyPropertyCollection);
}
if (data != null)
{
CheckForPotentialBrokenReferences(data, validationResult, type, dataScopeIdentifier, locale, dataKeyPropertyCollection);
}
}
}
}
}
if (validationResult.Count > 0)
{
_dataToDelete = null;
}
return(validationResult);
}
/// <exclude />
public override IEnumerable<PackageFragmentValidationResult> Validate()
{
var validationResult = new List<PackageFragmentValidationResult>();
if (this.Configuration.Count(f => f.Name == "Files") > 1)
{
validationResult.AddFatal(Texts.FilePackageFragmentUninstaller_OnlyOneFilesElement, ConfigurationParent);
return validationResult;
}
XElement filesElement = this.Configuration.SingleOrDefault(f => f.Name == "Files");
_filesToDelete = new List<string>();
_filesToCopy = new List<FileToCopy>();
if (filesElement != null)
{
foreach (XElement fileElement in filesElement.Elements("File").Reverse())
{
XAttribute filenameAttribute = fileElement.Attribute("filename");
if (filenameAttribute == null)
{
validationResult.AddFatal(Texts.FilePackageFragmentInstaller_MissingAttribute("filename"), fileElement);
continue;
}
string relativeFilePath = filenameAttribute.Value;
string filePath = PathUtil.Resolve(relativeFilePath);
string backupFile = (string) fileElement.Attribute("backupFile");
if (backupFile != null)
{
var backupFilePath = Path.Combine(UninstallerContext.PackageDirectory, "FileBackup", backupFile);
if (!C1File.Exists(backupFilePath))
{
validationResult.AddFatal("Missing backup file '{0}'".FormatWith(backupFilePath), fileElement);
continue;
}
_filesToCopy.Add(new FileToCopy
{
BackupFilePath = backupFilePath,
FilePath = filePath,
RelativeFilePath = relativeFilePath
});
}
else
{
_filesToDelete.Add(filePath);
}
}
}
if (validationResult.Count > 0)
{
_filesToDelete = null;
_filesToCopy = null;
}
return validationResult;
}
/// <exclude />
public override IEnumerable <PackageFragmentValidationResult> Validate()
{
var validationResult = new List <PackageFragmentValidationResult>();
var foreignKeyReferences = new List <string>();
if (this.Configuration.Count(f => f.Name == "Types") > 1)
{
validationResult.AddFatal(GetText("DynamicDataTypePackageFragmentInstaller.OnlyOneElement"));
return(validationResult);
}
XElement typesElement = this.Configuration.SingleOrDefault(f => f.Name == "Types");
if (typesElement == null)
{
validationResult.AddFatal(GetText("DynamicDataTypePackageFragmentInstaller.MissingElement"));
return(validationResult);
}
_dataTypeDescriptors = new List <DataTypeDescriptor>();
foreach (XElement typeElement in typesElement.Elements("Type"))
{
XAttribute dataTypeDescriptorAttribute = typeElement.Attribute("dataTypeDescriptor");
if (dataTypeDescriptorAttribute == null)
{
validationResult.AddFatal(GetText("DataTypePackageFragmentInstaller.MissingAttribute").FormatWith("dataTypeDescriptor"), typeElement);
continue;
}
XElement serializedDataTypeDescriptor;
try
{
serializedDataTypeDescriptor = XElement.Parse(dataTypeDescriptorAttribute.Value);
}
catch (Exception)
{
validationResult.AddFatal(GetText("DynamicDataTypePackageFragmentInstaller.DataTypeDescriptorParseError"), dataTypeDescriptorAttribute);
continue;
}
DataTypeDescriptor dataTypeDescriptor;
try
{
bool inheritedFieldsIncluded = serializedDataTypeDescriptor.Descendants().Any(e => e.Attributes("inherited").Any(a => (string)a == "true"));
dataTypeDescriptor = DataTypeDescriptor.FromXml(serializedDataTypeDescriptor, inheritedFieldsIncluded);
}
catch (Exception e)
{
validationResult.AddFatal(GetText("DynamicDataTypePackageFragmentInstaller.DataTypeDescriptorDeserializeError").FormatWith(e.Message));
continue;
}
Type type = TypeManager.TryGetType(dataTypeDescriptor.TypeManagerTypeName);
if ((type != null) && (DataFacade.GetAllKnownInterfaces().Contains(type)))
{
validationResult.AddFatal(GetText("DynamicDataTypePackageFragmentInstaller.TypeExists").FormatWith(type));
}
foreach (var field in dataTypeDescriptor.Fields)
{
if (!field.ForeignKeyReferenceTypeName.IsNullOrEmpty())
{
foreignKeyReferences.Add(field.ForeignKeyReferenceTypeName);
}
}
_dataTypeDescriptors.Add(dataTypeDescriptor);
this.InstallerContext.AddPendingDataTypeDescritpor(dataTypeDescriptor.TypeManagerTypeName, dataTypeDescriptor);
}
foreach (string foreignKeyTypeName in foreignKeyReferences)
{
if (!TypeManager.HasTypeWithName(foreignKeyTypeName) &&
!_dataTypeDescriptors.Any(descriptor => descriptor.TypeManagerTypeName == foreignKeyTypeName))
{
validationResult.AddFatal(GetText("DynamicDataTypePackageFragmentInstaller.MissingReferencedType").FormatWith(foreignKeyTypeName));
}
}
if (validationResult.Count > 0)
{
_dataTypeDescriptors = null;
}
return(validationResult);
}