/// <exclude />
public bool ValidateNewFieldDescriptors(IEnumerable <DataFieldDescriptor> newDataFieldDescriptors, string keyFieldName, out string message)
{
Verify.ArgumentNotNull(newDataFieldDescriptors, "newDataFieldDescriptors");
newDataFieldDescriptors = newDataFieldDescriptors.Evaluate();
message = null;
if (!newDataFieldDescriptors.Any(f => f.Name != keyFieldName))
{
message = Texts.MissingFields;
return(false);
}
if (keyFieldName != IdFieldName && newDataFieldDescriptors.Any(dfd => dfd.Name == IdFieldName))
{
message = Texts.FieldNameCannotBeUsed(IdFieldName);
return(false);
}
return(true);
}
/// <exclude />
public bool ValidateByCompile(out string errorMessage)
{
var dataTypeDescriptor = _oldDataTypeDescriptor == null?CreateNewDataTypeDescriptor() : CreateUpdatedDataTypeDescriptor();
var classFullName = (dataTypeDescriptor.Namespace + "." + dataTypeDescriptor.Name).Replace(" ", string.Empty);
var classFullNameWithDot = classFullName + ".";
foreach (var reservedNamespace in ReservedNamespaces)
{
if (classFullNameWithDot.StartsWith(reservedNamespace + ".", StringComparison.InvariantCultureIgnoreCase))
{
errorMessage = Texts.NamespaceIsReserved;
return(false);
}
}
foreach (var namePart in classFullName.Split(new[] { '.' }, StringSplitOptions.RemoveEmptyEntries))
{
if (!IsCSharpValidIdentifier(namePart))
{
errorMessage = Texts.TypeNameIsInvalidIdentifier(classFullName);
return(false);
}
}
foreach (var dataField in dataTypeDescriptor.Fields)
{
if (!IsCSharpValidIdentifier(dataField.Name))
{
errorMessage = Texts.FieldNameCannotBeUsed(dataField.Name);
return(false);
}
}
// Checking for name collisions with Composite.dll
if (classFullName.StartsWith(CompositeNamespace + ".", StringComparison.InvariantCultureIgnoreCase))
{
foreach (var type in typeof(IData).Assembly.GetTypes())
{
var typeNameWithDot = type.FullName + ".";
if (classFullNameWithDot.StartsWith(typeNameWithDot, StringComparison.InvariantCultureIgnoreCase) || typeNameWithDot.StartsWith(classFullNameWithDot, StringComparison.InvariantCultureIgnoreCase))
{
errorMessage = Texts.CompileErrorWhileAddingType;
return(false);
}
}
}
var compatibilityCheckResult = CodeCompatibilityChecker.CheckCompatibilityWithAppCodeFolder(dataTypeDescriptor);
if (!compatibilityCheckResult.Successful)
{
errorMessage = _oldDataTypeDescriptor == null ? Texts.CompileErrorWhileAddingType : Texts.CompileErrorWhileChangingType;
errorMessage += compatibilityCheckResult.ErrorMessage;
return(false);
}
errorMessage = string.Empty;
return(true);
}
/// <exclude />
public bool ValidateNewTypeFullName(string typeName, string typeNamespace, out string message)
{
Verify.ArgumentNotNullOrEmpty(typeName, "typeName");
Verify.ArgumentNotNullOrEmpty(typeNamespace, "typeNamespace");
message = null;
if (typeNamespace.Split('.').Contains(typeName))
{
message = Texts.TypeNameInNamespace(typeName, typeNamespace);
return(false);
}
if (_oldDataTypeDescriptor != null)
{
if (_oldDataTypeDescriptor.Name == typeName &&
_oldDataTypeDescriptor.Namespace == typeNamespace)
{
return(true);
}
var interfaceType = _oldDataTypeDescriptor.GetInterfaceType();
if (interfaceType.GetRefereeTypes().Count > 0)
{
message = Texts.TypesAreReferencing;
return(false);
}
}
var typeFullname = StringExtensionMethods.CreateNamespace(typeNamespace, typeName, '.');
foreach (var dtd in DataMetaDataFacade.GeneratedTypeDataTypeDescriptors)
{
var fullname = StringExtensionMethods.CreateNamespace(dtd.Namespace, dtd.Name, '.');
if (typeFullname == fullname)
{
message = Texts.TypesNameClash;
return(false);
}
}
var partNames = typeFullname.Split('.');
var sb = new StringBuilder(partNames[0]);
for (var i = 1; i < partNames.Length; i++)
{
var exists = TypeManager.HasTypeWithName(sb.ToString());
if (exists)
{
message = Texts.NameSpaceIsTypeTypeName(sb.ToString());
return(false);
}
sb.Append(".");
sb.Append(partNames[i]);
}
return(true);
}
