private DataTypeDescriptor GetDataTypeDescriptor() { Type sourceDataType = GetSourceDataType(); DataTypeDescriptor dataTypeDescriptor = null; if (DynamicTypeManager.TryGetDataTypeDescriptor(sourceDataType, out dataTypeDescriptor) == false) { dataTypeDescriptor = DynamicTypeManager.BuildNewDataTypeDescriptor(sourceDataType); } return(dataTypeDescriptor); }
private void EnsureInterfaces(IEnumerable <Type> allInterfaces) { var dataTypeDescriptors = new List <DataTypeDescriptor>(); foreach (Type interfaceType in allInterfaces) { if (!DataProviderRegistry.GetDataProviderNamesByInterfaceType(interfaceType).Contains(this.TargetProviderName)) { var dataTypeDescriptor = DynamicTypeManager.BuildNewDataTypeDescriptor(interfaceType); dataTypeDescriptor.Validate(); dataTypeDescriptors.Add(dataTypeDescriptor); } } DataProviderPluginFacade.CreateStores(this.TargetProviderName, dataTypeDescriptors); }
/// <summary> /// This method returns data type descriptors for dynamic types this is pending /// installation (Has passed validaion). /// </summary> /// <param name="interfaceName"></param> /// <returns></returns> public DataTypeDescriptor GetPendingDataTypeDescriptor(string interfaceName) { Verify.ArgumentNotNullOrEmpty(interfaceName, "interfaceName"); DataTypeDescriptor dataTypeDescriptor; if (_pendingDataTypeDescriptors.TryGetValue(interfaceName, out dataTypeDescriptor)) { return(dataTypeDescriptor); } Type interfaceType = _pendingDataTypes.FirstOrDefault(type => type.FullName == interfaceName); if (interfaceType == null) { return(null); } return(DynamicTypeManager.BuildNewDataTypeDescriptor(interfaceType)); }
public bool EnsureDataStores() { if (!DataProviderPluginFacade.HasConfiguration()) { Log.LogError(LogTitle, "Failed to load the configuration section '{0}' from the configuration", DataProviderSettings.SectionName); return(false); } var typeDescriptors = new List <DataTypeDescriptor>(); foreach (Type type in _interfaceTypes) { try { if (!DataProviderRegistry.AllKnownInterfaces.Contains(type)) { var dataTypeDescriptor = DynamicTypeManager.BuildNewDataTypeDescriptor(type); dataTypeDescriptor.Validate(); typeDescriptors.Add(dataTypeDescriptor); } } catch (Exception ex) { throw new InvalidOperationException(string.Format("Failed to validate type '{0}'", type), ex); } } if (typeDescriptors.Any()) { DataProviderPluginFacade.CreateStores(DataProviderRegistry.DefaultDynamicTypeDataProviderName, typeDescriptors); string typeNames = string.Join(", ", typeDescriptors.Select(t => t.GetFullInterfaceName())); Log.LogVerbose(LogTitle, "Stores for the following data types were created: " + typeNames); } return(typeDescriptors.Count > 0); }
/// <summary> /// Checks that tables related to specified data type included in current DataContext class, if not - compiles a new version of DataContext that contains them /// </summary> private HelperClassesGenerationInfo EnsureNeededTypes( DataTypeDescriptor dataTypeDescriptor, IEnumerable <SqlDataTypeStoreDataScope> sqlDataTypeStoreDataScopes, Dictionary <DataTypeDescriptor, IEnumerable <SqlDataTypeStoreDataScope> > allSqlDataTypeStoreDataScopes, Type dataContextClassType, out Dictionary <SqlDataTypeStoreTableKey, StoreTypeInfo> fields, ref bool dataContextRecompileNeeded, bool forceCompile = false) { lock (_lock) { // Getting the interface (ensuring that it exists) Type interfaceType = DataTypeTypesManager.GetDataType(dataTypeDescriptor); var storeDataScopesToCompile = new List <SqlDataTypeStoreDataScope>(); var storeDataScopesAlreadyCompiled = new List <SqlDataTypeStoreDataScope>(); fields = new Dictionary <SqlDataTypeStoreTableKey, StoreTypeInfo>(); foreach (SqlDataTypeStoreDataScope storeDataScope in sqlDataTypeStoreDataScopes) { string dataContextFieldName = NamesCreator.MakeDataContextFieldName(storeDataScope.TableName); FieldInfo dataContextFieldInfo = null; if (dataContextClassType != null) { dataContextFieldInfo = dataContextClassType.GetFields(BindingFlags.Public | BindingFlags.Instance) .SingleOrDefault(f => f.Name == dataContextFieldName); } string sqlDataProviderHelperClassFullName = NamesCreator.MakeSqlDataProviderHelperClassFullName(dataTypeDescriptor, storeDataScope.DataScopeName, storeDataScope.CultureName, _dataProviderContext.ProviderName); string entityClassName = NamesCreator.MakeEntityClassFullName(dataTypeDescriptor, storeDataScope.DataScopeName, storeDataScope.CultureName, _dataProviderContext.ProviderName); Type sqlDataProviderHelperClass = null, entityClass = null; try { sqlDataProviderHelperClass = TryGetGeneratedType(sqlDataProviderHelperClassFullName); entityClass = TryGetGeneratedType(entityClassName); forceCompile = forceCompile || CodeGenerationManager.IsRecompileNeeded(interfaceType, new[] { sqlDataProviderHelperClass, entityClass }); } catch (TypeLoadException) { forceCompile = true; } if (!forceCompile) { var storeTypeInfo = new StoreTypeInfo(dataContextFieldName, entityClass, sqlDataProviderHelperClass) { DataContextField = dataContextFieldInfo }; fields.Add(new SqlDataTypeStoreTableKey(storeDataScope.DataScopeName, storeDataScope.CultureName), storeTypeInfo); } if (dataContextFieldInfo == null) { dataContextRecompileNeeded = true; } if (forceCompile) { storeDataScopesToCompile.Add(storeDataScope); } else { storeDataScopesAlreadyCompiled.Add(storeDataScope); } } if (storeDataScopesToCompile.Any()) { dataContextRecompileNeeded = true; if (!dataTypeDescriptor.IsCodeGenerated) { // Building a new descriptor so generated classes take in account field changes dataTypeDescriptor = DynamicTypeManager.BuildNewDataTypeDescriptor(interfaceType); } return(CompileMissingClasses(dataTypeDescriptor, allSqlDataTypeStoreDataScopes, fields, storeDataScopesToCompile, storeDataScopesAlreadyCompiled)); } } return(null); }
private void ValidateNonDynamicAddedType(DataType dataType) { if (dataType.InterfaceType == null) { _validationResult.AddFatal(GetText("DataPackageFragmentInstaller.TypeNotConfigured").FormatWith(dataType.InterfaceTypeName)); return; } if (!typeof(IData).IsAssignableFrom(dataType.InterfaceType)) { _validationResult.AddFatal(GetText("DataPackageFragmentInstaller.TypeNotInheriting").FormatWith(dataType.InterfaceType, typeof(IData))); return; } bool dataTypeLocalized = DataLocalizationFacade.IsLocalized(dataType.InterfaceType); if (!ValidateTargetLocaleInfo(dataType, dataTypeLocalized)) { return; } int itemsAlreadyPresentInDatabase = 0; DataTypeDescriptor dataTypeDescriptor = DynamicTypeManager.BuildNewDataTypeDescriptor(dataType.InterfaceType); bool isVersionedDataType = typeof(IVersioned).IsAssignableFrom(dataType.InterfaceType); var requiredPropertyNames = (from dfd in dataTypeDescriptor.Fields where !dfd.IsNullable && !(isVersionedDataType && dfd.Name == nameof(IVersioned.VersionId)) // Compatibility fix select dfd.Name).ToList(); var nonRequiredPropertyNames = dataTypeDescriptor.Fields.Select(f => f.Name) .Except(requiredPropertyNames).ToList(); foreach (XElement addElement in dataType.Dataset) { var dataKeyPropertyCollection = new DataKeyPropertyCollection(); bool propertyValidationPassed = true; var assignedPropertyNames = new List <string>(); var fieldValues = new Dictionary <string, object>(); var properties = GetDataTypeProperties(dataType.InterfaceType); foreach (XAttribute attribute in addElement.Attributes()) { string fieldName = attribute.Name.LocalName; PropertyInfo propertyInfo; if (!properties.TryGetValue(fieldName, out propertyInfo)) { // A compatibility fix if (IsObsoleteField(dataType, fieldName)) { continue; } _validationResult.AddFatal(GetText("DataPackageFragmentInstaller.MissingProperty").FormatWith(dataType.InterfaceType, fieldName)); propertyValidationPassed = false; continue; } if (!propertyInfo.CanWrite) { _validationResult.AddFatal(GetText("DataPackageFragmentInstaller.MissingWritableProperty").FormatWith(dataType.InterfaceType, fieldName)); propertyValidationPassed = false; continue; } object fieldValue; try { fieldValue = ValueTypeConverter.Convert(attribute.Value, propertyInfo.PropertyType); } catch (Exception) { _validationResult.AddFatal(GetText("DataPackageFragmentInstaller.ConversionFailed").FormatWith(attribute.Value, propertyInfo.PropertyType)); propertyValidationPassed = false; continue; } if (dataType.InterfaceType.GetKeyPropertyNames().Contains(fieldName)) { dataKeyPropertyCollection.AddKeyProperty(fieldName, fieldValue); } assignedPropertyNames.Add(fieldName); fieldValues.Add(fieldName, fieldValue); } if (!propertyValidationPassed) { continue; } var notAssignedRequiredProperties = requiredPropertyNames.Except(assignedPropertyNames.Except(nonRequiredPropertyNames)).ToArray(); if (notAssignedRequiredProperties.Any()) { bool missingValues = false; foreach (string propertyName in notAssignedRequiredProperties) { PropertyInfo propertyInfo = dataType.InterfaceType.GetPropertiesRecursively().Single(f => f.Name == propertyName); if (propertyInfo.CanWrite) { var defaultValueAttribute = propertyInfo.GetCustomAttributesRecursively <NewInstanceDefaultFieldValueAttribute>().SingleOrDefault(); if (defaultValueAttribute == null || !defaultValueAttribute.HasValue) { _validationResult.AddFatal(GetText("DataPackageFragmentInstaller.MissingPropertyVaule").FormatWith(propertyName, dataType.InterfaceType)); missingValues = true; } } } if (missingValues) { continue; } } // Validating keys already present if (!dataType.AllowOverwrite && !dataType.OnlyUpdate) { bool dataLocaleExists = !DataLocalizationFacade.IsLocalized(dataType.InterfaceType) || (!dataType.AddToAllLocales && !dataType.AddToCurrentLocale) || (dataType.Locale != null && !this.InstallerContext.IsLocalePending(dataType.Locale)); if (dataLocaleExists) { using (new DataScope(dataType.DataScopeIdentifier, dataType.Locale)) { IData data = DataFacade.TryGetDataByUniqueKey(dataType.InterfaceType, dataKeyPropertyCollection); if (data != null) { itemsAlreadyPresentInDatabase++; } } } } RegisterKeyToBeAdded(dataType, dataKeyPropertyCollection); // Checking foreign key references foreach (var foreignKeyProperty in DataAttributeFacade.GetDataReferenceProperties(dataType.InterfaceType)) { if (!fieldValues.ContainsKey(foreignKeyProperty.SourcePropertyName)) { continue; } object propertyValue = fieldValues[foreignKeyProperty.SourcePropertyName]; if (propertyValue == null || propertyValue == foreignKeyProperty.NullReferenceValue) { continue; } CheckForBrokenReference(dataType, foreignKeyProperty.TargetType, foreignKeyProperty.TargetKeyPropertyName, propertyValue); } } if (itemsAlreadyPresentInDatabase > 0) { _validationResult.AddFatal(GetText("DataPackageFragmentInstaller.DataExists").FormatWith(dataType.InterfaceType, itemsAlreadyPresentInDatabase)); } }