private InitializeStoreResult EmbedDataContextInfo(InterfaceGeneratedClassesInfo initInfo, Type dataContextType)
{
var result = new InitializeStoreResult();
if (initInfo.InterfaceType == null)
{
return(result);
}
result.InterfaceType = initInfo.InterfaceType;
var sqlDataTypeStoreTables = new Dictionary <SqlDataTypeStoreTableKey, SqlDataTypeStoreTable>();
foreach (SqlDataTypeStoreDataScope storeDataScope in initInfo.DataScopes)
{
var key = new SqlDataTypeStoreTableKey(storeDataScope.DataScopeName, storeDataScope.CultureName);
result.TableNames.Add(key, storeDataScope.TableName);
Verify.IsNotNull(initInfo.Fields, "Fields collection is null");
StoreTypeInfo fieldInfo;
if (!initInfo.Fields.TryGetValue(key, out fieldInfo))
{
continue;
}
Verify.IsNotNull(fieldInfo, "Field info is missing");
FieldInfo dataContextFieldInfo = dataContextType != null
? dataContextType.GetField(fieldInfo.FieldName)
: fieldInfo.DataContextField;
Type sqlDataProvdierHelperType = fieldInfo.SqlHelperClass;
var sqlDataProviderHelper = (ISqlDataProviderHelper)Activator.CreateInstance(sqlDataProvdierHelperType);
var sqlDataTypeStoreTable = new SqlDataTypeStoreTable(
initInfo.DataTypeDescriptor.DataTypeId,
dataContextFieldInfo,
sqlDataProviderHelper,
fieldInfo.FieldName,
fieldInfo.FieldType);
_createdSqlDataTypeStoreTables.Add(sqlDataTypeStoreTable);
sqlDataTypeStoreTables.Add(key, sqlDataTypeStoreTable);
}
var sqlDataTypeStore = new SqlDataTypeStore(result.InterfaceType,
sqlDataTypeStoreTables,
initInfo.DataTypeDescriptor.IsCodeGenerated,
_sqlDataTypeStoresContainer);
result.SqlDataTypeStore = sqlDataTypeStore;
return(result);
}
public void AlterStore(UpdateDataTypeDescriptor updateDataTypeDescriptor, bool forceCompile)
{
var dataTypeChangeDescriptor = updateDataTypeDescriptor.CreateDataTypeChangeDescriptor();
using (TimerProfilerFacade.CreateTimerProfiler())
{
SqlStoreManipulator.AlterStoresForType(updateDataTypeDescriptor);
bool localizationChanged = dataTypeChangeDescriptor.AlteredType.Localizeable !=
dataTypeChangeDescriptor.OriginalType.Localizeable;
var oldElement = _interfaceConfigurationElements.Single(f => f.DataTypeId == updateDataTypeDescriptor.OldDataTypeDescriptor.DataTypeId);
var newElement = InterfaceConfigurationManipulator.Change(_dataProviderContext.ProviderName, dataTypeChangeDescriptor, localizationChanged);
if (newElement != null)
{
_interfaceConfigurationElements.Remove(oldElement);
_interfaceConfigurationElements.Add(newElement);
}
if (forceCompile)
{
Dictionary <DataTypeDescriptor, IEnumerable <SqlDataTypeStoreDataScope> > allSqlDataTypeStoreDataScopes = BuildAllExistingDataTypeStoreDataScopes();
InitializeStoreResult initializeStoreResult = InitializeStore(newElement ?? oldElement, allSqlDataTypeStoreDataScopes, true);
if (!updateDataTypeDescriptor.NewDataTypeDescriptor.IsCodeGenerated)
{
var interfaceType = updateDataTypeDescriptor.NewDataTypeDescriptor.GetInterfaceType();
if (!DataTypeValidationRegistry.IsValidForProvider(interfaceType, _dataProviderContext.ProviderName))
{
// Revalidating alternated static data type
_sqlDataTypeStoresContainer.RemoveKnownInterface(interfaceType);
DataTypeValidationRegistry.ClearValidationError(interfaceType, _dataProviderContext.ProviderName);
AddDataTypeStore(initializeStoreResult);
}
}
}
}
}
private bool ValidateTables(InitializeStoreResult initializeStoreResult, bool isInitialization)
{
var errors = new StringBuilder();
bool isValid = true;
var interfaceType = initializeStoreResult.InterfaceType;
foreach (string tableName in initializeStoreResult.TableNames.Values)
{
bool isTableValid = ValidateTable(interfaceType, tableName, errors);
if (!isTableValid)
{
isValid = false;
}
}
if (!isValid)
{
DataTypeValidationRegistry.AddValidationError(initializeStoreResult.InterfaceType, _dataProviderContext.ProviderName, errors.ToString());
if (isInitialization &&
GlobalSettingsFacade.EnableDataTypesAutoUpdate &&
interfaceType.IsAutoUpdateble() &&
!interfaceType.IsGenerated())
{
Log.LogInformation(LogTitle, "Data schema for the data interface '{0}' on the SqlDataProvider '{1}' is not matching and will be updated.",
initializeStoreResult.InterfaceType, _dataProviderContext.ProviderName);
Log.LogInformation(LogTitle, errors.ToString());
}
else
{
Log.LogCritical(LogTitle, "The data interface '{0}' will not work for the SqlDataProvider '{1}'",
initializeStoreResult.InterfaceType, _dataProviderContext.ProviderName);
Log.LogCritical(LogTitle, errors.ToString());
}
}
return(isValid);
}
private void AddDataTypeStore(InitializeStoreResult initializeStoreResult, bool doValidate = true, bool isInitialization = false)
{
if (initializeStoreResult.InterfaceType == null)
{
return;
}
bool isValid = initializeStoreResult.SqlDataTypeStore != null;
if (isValid && doValidate)
{
isValid = ValidateTables(initializeStoreResult, isInitialization);
}
if (!isValid)
{
_sqlDataTypeStoresContainer.AddKnownInterface(initializeStoreResult.InterfaceType);
return;
}
_sqlDataTypeStoresContainer.AddSupportedDataTypeStore(initializeStoreResult.InterfaceType, initializeStoreResult.SqlDataTypeStore);
DataProviderRegistry.AddNewDataType(initializeStoreResult.InterfaceType, _dataProviderContext.ProviderName);
}
public void CreateStores(IReadOnlyCollection <DataTypeDescriptor> dataTypeDescriptors)
{
var types = DataTypeTypesManager.GetDataTypes(dataTypeDescriptors);
foreach (var dataTypeDescriptor in dataTypeDescriptors)
{
if (InterfaceConfigurationManipulator.ConfigurationExists(_dataProviderContext.ProviderName, dataTypeDescriptor))
{
var filePath = InterfaceConfigurationManipulator.GetConfigurationFilePath(_dataProviderContext.ProviderName);
throw new InvalidOperationException(
$"SqlDataProvider configuration already contains a interface named '{dataTypeDescriptor.TypeManagerTypeName}', Id: '{dataTypeDescriptor.DataTypeId}'. Remove it from the configuration file '{filePath}' and restart the application.");
}
}
// Creating Sql tables and adding to the configuration
var configElements = new Dictionary <DataTypeDescriptor, InterfaceConfigurationElement>();
foreach (var dataTypeDescriptor in dataTypeDescriptors)
{
Type type = types[dataTypeDescriptor.DataTypeId];
Action <string> existingTablesValidator = tableName =>
{
var errors = new StringBuilder();
var interfaceType = type;
if (!ValidateTable(interfaceType, tableName, errors))
{
throw new InvalidOperationException("Table '{0}' already exist but isn't valid: {1}".FormatWith(tableName, errors.ToString()));
}
};
SqlStoreManipulator.CreateStoresForType(dataTypeDescriptor, existingTablesValidator);
InterfaceConfigurationElement element = InterfaceConfigurationManipulator.AddNew(_dataProviderContext.ProviderName, dataTypeDescriptor);
_interfaceConfigurationElements.Add(element);
configElements.Add(dataTypeDescriptor, element);
}
// Generating necessary classes and performing validation
Dictionary <DataTypeDescriptor, IEnumerable <SqlDataTypeStoreDataScope> > allSqlDataTypeStoreDataScopes = BuildAllExistingDataTypeStoreDataScopes();
bool dataContextRecompilationNeeded = false;
var toCompileList = new List <HelperClassesGenerationInfo>();
var generatedClassesInfo = new Dictionary <DataTypeDescriptor, InterfaceGeneratedClassesInfo>();
Type dataContextClass = _sqlDataTypeStoresContainer.DataContextClass;
foreach (var dataTypeDescriptor in dataTypeDescriptors)
{
var element = configElements[dataTypeDescriptor];
// InitializeStoreResult initializeStoreResult = InitializeStore(element, allSqlDataTypeStoreDataScopes);
HelperClassesGenerationInfo toCompile = null;
var classesInfo = InitializeStoreTypes(element, allSqlDataTypeStoreDataScopes, dataContextClass, null, false, ref dataContextRecompilationNeeded, ref toCompile);
if (classesInfo != null && toCompile != null)
{
toCompileList.Add(toCompile);
generatedClassesInfo[dataTypeDescriptor] = classesInfo;
}
}
// Compiling missing classes
if (toCompileList.Any())
{
var codeGenerationBuilder = new CodeGenerationBuilder(_dataProviderContext.ProviderName + ":CreateStores");
foreach (var toCompile in toCompileList)
{
toCompile.GenerateCodeAction(codeGenerationBuilder);
}
var generatedHelperClasses = CodeGenerationManager.CompileRuntimeTempTypes(codeGenerationBuilder, false).ToArray();
foreach (var toCompile in toCompileList)
{
toCompile.PopulateFieldsAction(generatedHelperClasses);
}
}
// Emitting a new DataContext class
if (dataContextRecompilationNeeded)
{
var newDataTypeIds = new HashSet <Guid>(dataTypeDescriptors.Select(d => d.DataTypeId));
_createdSqlDataTypeStoreTables.RemoveAll(f => newDataTypeIds.Contains(f.DataTypeId));
var fields = _createdSqlDataTypeStoreTables.Select(s => new Tuple <string, Type>(s.DataContextFieldName, s.DataContextFieldType)).ToList();
foreach (var classesInfo in generatedClassesInfo.Values)
{
fields.AddRange(classesInfo.Fields.Select(f => new Tuple <string, Type>(f.Value.FieldName, f.Value.FieldType)));
}
dataContextClass = DataContextAssembler.EmitDataContextClass(fields);
UpdateCreatedSqlDataTypeStoreTables(dataContextClass);
}
_sqlDataTypeStoresContainer.DataContextClass = dataContextClass;
// Registering the new type/tables
foreach (var dataTypeDescriptor in dataTypeDescriptors)
{
InterfaceGeneratedClassesInfo classesInfo;
if (!generatedClassesInfo.TryGetValue(dataTypeDescriptor, out classesInfo))
{
throw new InvalidOperationException("No generated classes for data type '{0}' found".FormatWith(dataTypeDescriptor.Name));
}
InitializeStoreResult initInfo = EmbedDataContextInfo(classesInfo, dataContextClass);
AddDataTypeStore(initInfo, false);
}
}
private bool ValidateTables(InitializeStoreResult initializeStoreResult, bool isInitialization)
{
var errors = new StringBuilder();
bool isValid = true;
var interfaceType = initializeStoreResult.InterfaceType;
foreach (string tableName in initializeStoreResult.TableNames.Values)
{
bool isTableValid = ValidateTable(interfaceType, tableName, errors);
if (!isTableValid) isValid = false;
}
if (!isValid)
{
DataTypeValidationRegistry.AddValidationError(initializeStoreResult.InterfaceType, _dataProviderContext.ProviderName, errors.ToString());
if (isInitialization
&& GlobalSettingsFacade.EnableDataTypesAutoUpdate
&& interfaceType.IsAutoUpdateble()
&& !interfaceType.IsGenerated())
{
Log.LogInformation(LogTitle, "Data schema for the data interface '{0}' on the SqlDataProvider '{1}' is not matching and will be updated.",
initializeStoreResult.InterfaceType, _dataProviderContext.ProviderName);
Log.LogInformation(LogTitle, errors.ToString());
}
else
{
Log.LogCritical(LogTitle, "The data interface '{0}' will not work for the SqlDataProvider '{1}'",
initializeStoreResult.InterfaceType, _dataProviderContext.ProviderName);
Log.LogCritical(LogTitle, errors.ToString());
}
}
return isValid;
}
private InitializeStoreResult EmbedDataContextInfo(InterfaceGeneratedClassesInfo initInfo, Type dataContextType)
{
var result = new InitializeStoreResult();
if (initInfo.InterfaceType == null)
{
return result;
}
result.InterfaceType = initInfo.InterfaceType;
var sqlDataTypeStoreTables = new Dictionary<SqlDataTypeStoreTableKey, SqlDataTypeStoreTable>();
foreach (SqlDataTypeStoreDataScope storeDataScope in initInfo.DataScopes)
{
var key = new SqlDataTypeStoreTableKey(storeDataScope.DataScopeName, storeDataScope.CultureName);
result.TableNames.Add(key, storeDataScope.TableName);
Verify.IsNotNull(initInfo.Fields, "Fields collection is null");
StoreTypeInfo fieldInfo;
if (!initInfo.Fields.TryGetValue(key, out fieldInfo))
{
continue;
}
Verify.IsNotNull(fieldInfo, "Field info is missing");
FieldInfo dataContextFieldInfo = dataContextType != null
? dataContextType.GetField(fieldInfo.FieldName)
: fieldInfo.DataContextField;
Type sqlDataProvdierHelperType = fieldInfo.SqlHelperClass;
var sqlDataProviderHelper = (ISqlDataProviderHelper)Activator.CreateInstance(sqlDataProvdierHelperType);
var sqlDataTypeStoreTable = new SqlDataTypeStoreTable(
initInfo.DataTypeDescriptor.DataTypeId,
dataContextFieldInfo,
sqlDataProviderHelper,
fieldInfo.FieldName,
fieldInfo.FieldType);
_createdSqlDataTypeStoreTables.Add(sqlDataTypeStoreTable);
sqlDataTypeStoreTables.Add(key, sqlDataTypeStoreTable);
}
var sqlDataTypeStore = new SqlDataTypeStore(result.InterfaceType,
sqlDataTypeStoreTables,
initInfo.DataTypeDescriptor.IsCodeGenerated,
_sqlDataTypeStoresContainer);
result.SqlDataTypeStore = sqlDataTypeStore;
return result;
}
private void AddDataTypeStore(InitializeStoreResult initializeStoreResult, bool doValidate = true, bool isInitialization = false)
{
if (initializeStoreResult.InterfaceType == null)
{
return;
}
bool isValid = initializeStoreResult.SqlDataTypeStore != null;
if (isValid && doValidate)
{
isValid = ValidateTables(initializeStoreResult, isInitialization);
}
if (!isValid)
{
_sqlDataTypeStoresContainer.AddKnownInterface(initializeStoreResult.InterfaceType);
return;
}
_sqlDataTypeStoresContainer.AddSupportedDataTypeStore(initializeStoreResult.InterfaceType, initializeStoreResult.SqlDataTypeStore);
DataProviderRegistry.AddNewDataType(initializeStoreResult.InterfaceType, _dataProviderContext.ProviderName);
}
