private bool RunDocumentValidityChecks()
{
// Assure that each element has a GUID and language child element
foreach (var element in DocumentElements)
{
if (element.Element(XmlConstants.EntityGuid) == null)
{
element.Add(new XElement(XmlConstants.EntityGuid, ""));
}
if (element.Element(XmlConstants.EntityLanguage) == null)
{
element.Add(new XElement(XmlConstants.EntityLanguage, ""));
}
}
var documentElementLanguagesAll = DocumentElements
.GroupBy(element => element.Element(XmlConstants.EntityGuid)?.Value)
.Select(group => @group
.Select(element => element.Element(XmlConstants.EntityLanguage)?.Value)
.ToList())
.ToList();
var documentElementLanguagesCount = documentElementLanguagesAll.Select(item => item.Count);
if (documentElementLanguagesCount.Any(count => count != 1))
{
// It is an all language import, so check if all languages are specified for all entities
if (documentElementLanguagesAll.Any(lang => _languages.Except(lang).Any()))
{
ErrorLog.AppendError(ImportErrorCode.MissingElementLanguage,
"Langs=" + string.Join(", ", _languages));
return(false);
}
}
return(true);
}
private bool LoadStreamIntoDocumentElement(Stream dataStream)
{
Document = XDocument.Load(dataStream);
dataStream.Position = 0;
if (Document == null)
{
ErrorLog.AppendError(ImportErrorCode.InvalidDocument);
return(false);
}
var documentRoot = Document.Element(XmlConstants.Root);
if (documentRoot == null)
{
throw new Exception("can't import - document doesn't have a root element");
}
DocumentElements = documentRoot.Elements(XmlConstants.Entity).ToList();
if (!DocumentElements.Any())
{
ErrorLog.AppendError(ImportErrorCode.InvalidDocument);
return(false);
}
// Check the content type of the document (it can be found on each element in the Type attribute)
var documentTypeAttribute = DocumentElements.First().Attribute(XmlConstants.EntityTypeAttribute);
if (documentTypeAttribute?.Value == null ||
documentTypeAttribute.Value != ContentType.Name.RemoveSpecialCharacters())
{
ErrorLog.AppendError(ImportErrorCode.InvalidRoot);
return(false);
}
return(true);
}
/// <summary>
/// Deserialize data xml stream to the memory. The data will also be checked for
/// errors.
/// </summary>
private void ValidateAndImportToMemory()
{
var documentElementNumber = 0;
var entityGuidManager = new ImportItemGuidManager();
foreach (var documentElement in DocumentElements)
{
documentElementNumber++;
var documentElementLanguage = documentElement.Element(XmlConstants.EntityLanguage)?.Value;
if (_languages.All(language => language != documentElementLanguage))
{
// DNN does not support the language
ErrorLog.AppendError(ImportErrorCode.InvalidLanguage, "Lang=" + documentElementLanguage,
documentElementNumber);
continue;
}
var entityGuid = entityGuidManager.GetGuid(documentElement, _documentLanguageFallback);
var entity = GetImportEntity(entityGuid) ?? AppendEntity(entityGuid);
foreach (var attribute in AttributesOfType)
{
var valueType = attribute.Type;
var valueName = attribute.StaticName;
var value = documentElement.Element(valueName)?.Value;
if (value == null || value == XmlConstants.Null /* "[]" */) // value.IsValueNull())
{
continue;
}
if (value == XmlConstants.Empty /* "[\"\"]" */) //value.IsValueEmpty())
{
// It is an empty string
entity.Attributes.AddValue(valueName, "", attribute.Type, documentElementLanguage, false,
_resolveReferenceMode == ImportResourceReferenceMode.Resolve);
continue;
}
var valueReferenceLanguage = value.GetLanguageInARefTextCode();
if (valueReferenceLanguage == null) // It is not a value reference.. it is a normal text
{
try
{
entity.Attributes.AddValue(valueName, value, valueType, documentElementLanguage, false,
_resolveReferenceMode == ImportResourceReferenceMode.Resolve);
}
catch (FormatException)
{
ErrorLog.AppendError(ImportErrorCode.InvalidValueFormat,
valueName + ":" + valueType + "=" + value, documentElementNumber);
}
continue;
}
var valueReferenceProtection = value.GetValueReferenceProtection();
if (valueReferenceProtection != XmlConstants.ReadWrite /* "rw" */ && valueReferenceProtection != XmlConstants.ReadOnly /* "ro" */)
{
ErrorLog.AppendError(ImportErrorCode.InvalidValueReferenceProtection, value,
documentElementNumber);
continue;
}
var valueReadOnly = valueReferenceProtection == XmlConstants.ReadOnly /* "ro" */;
// if this value is just a placeholder/reference to another value,
// then find the master record, and add this language to it's users
var entityValue = entity.Attributes.FindItemOfLanguage(valueName, valueReferenceLanguage);
if (entityValue != null)
{
entityValue.Languages.Add(new Dimension {
Key = documentElementLanguage, ReadOnly = valueReadOnly
});
continue;
}
// We do not have the value referenced in memory, so search for the
// value in the database
var dbEntity = FindInExisting(entityGuid); // _contentType.EntityByGuid(entityGuid);
if (dbEntity == null)
{
ErrorLog.AppendError(ImportErrorCode.InvalidValueReference, value, documentElementNumber);
continue;
}
var dbEntityValue = dbEntity.GetValueOfExactLanguage(attribute, valueReferenceLanguage);
if (dbEntityValue == null)
{
ErrorLog.AppendError(ImportErrorCode.InvalidValueReference, value, documentElementNumber);
continue;
}
entity.Attributes.AddValue(valueName, dbEntityValue.Value, valueType, valueReferenceLanguage,
dbEntityValue.IsLanguageReadOnly(valueReferenceLanguage),
_resolveReferenceMode == ImportResourceReferenceMode.Resolve)
//.AddLanguageReference(documentElementLanguage, valueReadOnly);
.Languages.Add(new Dimension {
Key = documentElementLanguage, ReadOnly = valueReadOnly
});
}
}
}