public void CreateStores(IReadOnlyCollection <DataTypeDescriptor> dataTypeDescriptors)
{
var dataTypes = DataTypeTypesManager.GetDataTypes(dataTypeDescriptors);
var storesToCreate = new List <GeneratedTypesInfo>();
foreach (var dataTypeDescriptor in dataTypeDescriptors)
{
Type interfaceType = dataTypes[dataTypeDescriptor.DataTypeId];
storesToCreate.Add(BuildGeneratedTypesInfo(dataTypeDescriptor, interfaceType));
}
CompileMissingTypes(storesToCreate);
foreach (var storeToCreate in storesToCreate)
{
var dataTypeDescriptor = storeToCreate.DataTypeDescriptor;
InterfaceConfigurationManipulator.AddNew(_dataProviderContext.ProviderName, dataTypeDescriptor);
var xmlDataTypeStoreCreator = new XmlDataTypeStoreCreator(_fileStoreDirectory);
XmlDataTypeStore xmlDateTypeStore = xmlDataTypeStoreCreator.CreateStoreResult(
dataTypeDescriptor,
storeToCreate.DataProviderHelperClass,
storeToCreate.DataIdClass, null);
Type interfaceType = storeToCreate.InterfaceType;
AddDataTypeStore(dataTypeDescriptor, interfaceType, xmlDateTypeStore);
}
}
public void DropStore(DataTypeDescriptor typeDescriptor)
{
XmlDataProviderDocumentCache.ClearCache();
InterfaceConfigurationManipulator.Remove(_dataProviderContext.ProviderName, typeDescriptor);
_dataTypeConfigurationElements = _dataTypeConfigurationElements.Where(s => s.DataTypeId != typeDescriptor.DataTypeId).Evaluate();
}
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);
}
}
}
}
}
public void RemoveLocale(CultureInfo cultureInfo)
{
var supportedInterfaces = GetSupportedInterfaces();
foreach (var type in supportedInterfaces)
{
if (!DataLocalizationFacade.IsLocalized(type))
{
continue;
}
var typeDesrciptor = DynamicTypeManager.GetDataTypeDescriptor(type);
SqlStoreManipulator.RemoveLocale(_dataProviderContext.ProviderName, typeDesrciptor, cultureInfo);
InterfaceConfigurationElement oldElement = _interfaceConfigurationElements.Where(f => f.DataTypeId == typeDesrciptor.DataTypeId).Single();
InterfaceConfigurationElement newElement = InterfaceConfigurationManipulator.RefreshLocalizationInfo(_dataProviderContext.ProviderName, typeDesrciptor);
_interfaceConfigurationElements.Remove(oldElement);
_interfaceConfigurationElements.Add(newElement);
}
}
public void AlterStore(UpdateDataTypeDescriptor updateDataTypeDescriptor, bool forceCompile)
{
XmlDataProviderDocumentCache.ClearCache();
XmlProviderInterfaceConfigurationElement element = InterfaceConfigurationManipulator.Change(updateDataTypeDescriptor);
if (forceCompile)
{
DataTypeDescriptor dataTypeDescriptor = updateDataTypeDescriptor.NewDataTypeDescriptor;
Type dataProviderHelperType;
Type dataIdClassType;
bool typesExists = EnsureNeededTypes(dataTypeDescriptor, out dataProviderHelperType, out dataIdClassType, true);
Verify.That(typesExists, "Could not find or code generated the type '{0}' or one of the needed helper types", dataTypeDescriptor.GetFullInterfaceName());
var xmlDataTypeStoreDataScopes = new List <XmlDataTypeStoreDataScope>();
foreach (DataScopeConfigurationElement dataScopeConfigurationElement in element.ConfigurationStores)
{
var xmlDataTypeStoreDataScope = new XmlDataTypeStoreDataScope
{
DataScopeName = dataScopeConfigurationElement.DataScope,
CultureName = dataScopeConfigurationElement.CultureName,
ElementName = dataScopeConfigurationElement.ElementName,
Filename = Path.Combine(_fileStoreDirectory, dataScopeConfigurationElement.Filename)
};
xmlDataTypeStoreDataScopes.Add(xmlDataTypeStoreDataScope);
}
var xmlDataTypeStoreCreator = new XmlDataTypeStoreCreator(_fileStoreDirectory);
XmlDataTypeStore xmlDateTypeStore = xmlDataTypeStoreCreator.CreateStoreResult(dataTypeDescriptor, dataProviderHelperType, dataIdClassType, xmlDataTypeStoreDataScopes);
Type interfaceType = DataTypeTypesManager.GetDataType(dataTypeDescriptor);
UpdateDataTypeStore(dataTypeDescriptor, interfaceType, xmlDateTypeStore);
}
}
public void DropStore(DataTypeDescriptor dataTypeDescriptor)
{
using (TimerProfilerFacade.CreateTimerProfiler())
{
SqlStoreManipulator.DropStoresForType(_dataProviderContext.ProviderName, dataTypeDescriptor);
InterfaceConfigurationManipulator.Remove(_dataProviderContext.ProviderName, dataTypeDescriptor);
InterfaceConfigurationElement oldElement = _interfaceConfigurationElements.FirstOrDefault(f => f.DataTypeId == dataTypeDescriptor.DataTypeId);
if (oldElement != null)
{
_interfaceConfigurationElements.Remove(oldElement);
}
Guid dataTypeId = dataTypeDescriptor.DataTypeId;
int storesRemoved = _createdSqlDataTypeStoreTables.RemoveAll(item => item.DataTypeId == dataTypeId);
if (storesRemoved > 0)
{
Type interfaceType = dataTypeDescriptor.GetInterfaceType();
_sqlDataTypeStoresContainer.ForgetInterface(interfaceType);
}
}
}
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);
}
}
public void RemoveLocale(CultureInfo cultureInfo)
{
XmlDataProviderDocumentCache.ClearCache();
InterfaceConfigurationManipulator.RemoveLocale(_dataProviderContext.ProviderName, this.GetSupportedInterfaces(), cultureInfo);
}
public IDataProvider Assemble(IBuilderContext context, DataProviderData objectConfiguration, IConfigurationSource configurationSource, ConfigurationReflectionCache reflectionCache)
{
var sqlDataProviderData = (SqlDataProviderData)objectConfiguration;
string configFilePath = InterfaceConfigurationManipulator.GetConfigurationFilePath(sqlDataProviderData.Name);
var configuration = new C1Configuration(configFilePath);
var section = configuration.GetSection(SqlDataProviderConfigurationSection.SectionName) as SqlDataProviderConfigurationSection;
if (section == null)
{
section = new SqlDataProviderConfigurationSection();
configuration.Sections.Add(SqlDataProviderConfigurationSection.SectionName, section);
configuration.Save();
}
var interfaceConfigurationElements = new List <InterfaceConfigurationElement>();
foreach (InterfaceConfigurationElement table in section.Interfaces)
{
interfaceConfigurationElements.Add(table);
}
var sqlLoggingContext = new SqlLoggingContext
{
Enabled = sqlDataProviderData.SqlQueryLoggingEnabled,
IncludeStack = sqlDataProviderData.SqlQueryLoggingIncludeStack,
TypesToIgnore = new List <Type>(),
TablesToIgnore = new List <string>()
};
if (sqlDataProviderData.SqlQueryLoggingEnabled)
{
foreach (LoggingIgnoreInterfacesConfigurationElement element in sqlDataProviderData.LoggingIgnoreInterfaces)
{
Type interfaceType = TypeManager.TryGetType(element.InterfaceType);
if (interfaceType != null)
{
sqlLoggingContext.TypesToIgnore.Add(interfaceType);
InterfaceConfigurationElement interfaceElement = interfaceConfigurationElements.SingleOrDefault(f => f.DataTypeId == interfaceType.GetImmutableTypeId());
if (interfaceElement == null)
{
continue;
}
foreach (StoreConfigurationElement store in interfaceElement.ConfigurationStores)
{
sqlLoggingContext.TablesToIgnore.Add(store.TableName);
}
}
}
}
string connectionString = sqlDataProviderData.ConnectionString;
if (string.IsNullOrEmpty(connectionString))
{
string connectionStringName = sqlDataProviderData.ConnectionStringName;
if (string.IsNullOrEmpty(connectionStringName))
{
throw new ConfigurationErrorsException("SqlDataProvider requires one of the following properties to be specified: 'connectionString', 'connectionStringName'");
}
var connStringConfigNode = System.Web.Configuration.WebConfigurationManager.ConnectionStrings[connectionStringName];
Verify.IsNotNull(connStringConfigNode, "Failed to find an SQL connection string by name '{0}'", connectionStringName);
connectionString = connStringConfigNode.ConnectionString;
}
return(new SqlDataProvider(connectionString, interfaceConfigurationElements, sqlLoggingContext));
}
