public static IActionTokenProvider GetActionTokenProvider(Type elementProviderType, string actionTypeName) { Dictionary<string, IActionTokenProvider> actionTokenProviders; using (_resourceLocker.Locker) { if (_resourceLocker.Resources.ActionTokenProviderCache.TryGetValue(elementProviderType, out actionTokenProviders) == false) { actionTokenProviders = new Dictionary<string, IActionTokenProvider>(); var pairs = (from t in elementProviderType.GetCustomAttributesRecursively<ActionTokenProviderAttribute>() select new { ActionTypeName = t.ActionTypeName, ActionTokenProviderType = t.ActionTokenProviderType }); foreach (var pair in pairs) { if (actionTokenProviders.ContainsKey(pair.ActionTypeName) == false) { IActionTokenProvider newActionTokenProvider = (IActionTokenProvider)Activator.CreateInstance(pair.ActionTokenProviderType); actionTokenProviders.Add(pair.ActionTypeName, newActionTokenProvider); } } _resourceLocker.Resources.ActionTokenProviderCache.Add(elementProviderType, actionTokenProviders); } IActionTokenProvider actionTokenProvider; actionTokenProviders.TryGetValue(actionTypeName, out actionTokenProvider); return actionTokenProvider; } }
public static bool IsActionIgnored(Type elementProviderType, string actionTypeName) { List<string> ignoredActionTypes; using (_resourceLocker.Locker) { if (_resourceLocker.Resources.IgnoreActionCache.TryGetValue(elementProviderType, out ignoredActionTypes) == false) { ignoredActionTypes = (from t in elementProviderType.GetCustomAttributesRecursively<IgnoreActionAttribute>() select t.ActionTypeName).Distinct().ToList(); _resourceLocker.Resources.IgnoreActionCache.Add(elementProviderType, ignoredActionTypes); } } return ignoredActionTypes.Contains(actionTypeName); }
/// <exclude /> public static DataTypeDescriptor Build(Type type) { Verify.ArgumentNotNull(type, "type"); Verify.ArgumentCondition(typeof(IData).IsAssignableFrom(type), "type", "{0} does not implement {1}".FormatWith(type.FullName, typeof(IData).FullName)); Guid dataTypeId = DynamicTypeReflectionFacade.GetImmutableTypeId(type); bool isCodeGenerated = type.GetCustomInterfaceAttributes<CodeGeneratedAttribute>().Any(); var typeDescriptor = new DataTypeDescriptor(dataTypeId, type.Namespace, type.Name, TypeManager.SerializeType(type), isCodeGenerated) { Title = DynamicTypeReflectionFacade.GetTitle(type), LabelFieldName = DynamicTypeReflectionFacade.GetLabelPropertyName(type), InternalUrlPrefix = DynamicTypeReflectionFacade.GetInternalUrlPrefix(type), DataAssociations = DynamicTypeReflectionFacade.GetDataTypeAssociationDescriptors(type) }; List<Type> superInterfaces = type.GetInterfacesRecursively(t => typeof(IData).IsAssignableFrom(t) && t != typeof(IData)); typeDescriptor.SetSuperInterfaces(superInterfaces); Type buildNewHandlerType = DynamicTypeReflectionFacade.GetBuildNewHandlerType(type); if (buildNewHandlerType != null) typeDescriptor.BuildNewHandlerTypeName = TypeManager.SerializeType(buildNewHandlerType); foreach (PropertyInfo propertyInfo in type.GetProperties()) { DataFieldDescriptor fieldDescriptor = BuildFieldDescriptor(propertyInfo, false); typeDescriptor.Fields.Add(fieldDescriptor); } foreach (Type superInterfaceType in superInterfaces) { foreach (PropertyInfo propertyInfo in superInterfaceType.GetProperties()) { if (propertyInfo.Name == nameof(IPageData.PageId) && propertyInfo.DeclaringType == typeof(IPageData)) { continue; } DataFieldDescriptor fieldDescriptor = BuildFieldDescriptor(propertyInfo, true); typeDescriptor.Fields.Add(fieldDescriptor); } } ValidateAndAddKeyProperties(typeDescriptor.KeyPropertyNames, typeDescriptor.VersionKeyPropertyNames, type); string[] storeSortOrder = DynamicTypeReflectionFacade.GetSortOrder(type); if (storeSortOrder != null) { foreach (string name in storeSortOrder) { typeDescriptor.StoreSortOrderFieldNames.Add(name); } } CheckSortOrder(typeDescriptor); foreach (var dataScopeIdentifier in DynamicTypeReflectionFacade.GetDataScopes(type)) { if (!typeDescriptor.DataScopes.Contains(dataScopeIdentifier)) { typeDescriptor.DataScopes.Add(dataScopeIdentifier); } } foreach (string keyPropertyName in type.GetKeyPropertyNames()) { if (typeDescriptor.Fields[keyPropertyName] == null) { throw new InvalidOperationException( $"The type '{type}' has a non existing key property specified by the attribute '{typeof (KeyPropertyNameAttribute)}'"); } } var indexes = new List<DataTypeIndex>(); foreach (var indexAttribute in type.GetCustomAttributesRecursively<IndexAttribute>()) { foreach (var field in indexAttribute.Fields) { if (typeDescriptor.Fields[field.Item1] == null) { throw new InvalidOperationException($"Index field '{field.Item1}' is not defined"); } } indexes.Add(new DataTypeIndex(indexAttribute.Fields) { Clustered = indexAttribute.Clustered }); } indexes.Sort((a,b) => string.Compare(a.ToString(), b.ToString(), StringComparison.Ordinal)); typeDescriptor.Indexes = indexes; return typeDescriptor; }
private static void AddProcessController(Resources resources, Type interfaceType, Type superProcessControllerInterfaceType, Type attributeType, Dictionary<Type, Type> processControllerTypes) { var publishAttributes = interfaceType.GetCustomAttributesRecursively(attributeType).Cast<ProcessControllerTypeAttribute>().ToList(); if (publishAttributes.Count == 0) return; Type processControllerType = publishAttributes[0].ProcessControllerType; foreach (ProcessControllerTypeAttribute attribute in publishAttributes.Skip(1)) { Verify.That(attribute.ProcessControllerType != processControllerType, "Only one '{0}' is allowed on the data type '{1}' or all attributes should have same process controller type", processControllerType, interfaceType); } processControllerTypes.Add(superProcessControllerInterfaceType, processControllerType); if (!resources.ProcessControllerTypes.Contains(processControllerType)) { resources.ProcessControllerTypes.Add(processControllerType); } }
private static void AddNewType(Type interfaceType) { List<DataAssociationAttribute> attributes = interfaceType.GetCustomAttributesRecursively<DataAssociationAttribute>().ToList(); if (attributes.Count == 0) { return; } var dataAssociationInfos = new Dictionary<Type, DataAssociationInfo>(); foreach (DataAssociationAttribute attribute in attributes) { if (attribute.AssociationType == DataAssociationType.None) throw new ArgumentException(string.Format("The associationType on the attribute '{0}' on the interface type '{1}' may not be '{2}'", typeof(DataAssociationAttribute), interfaceType, DataAssociationType.None)); if (attribute.AssociatedInterfaceType == null) throw new ArgumentNullException(string.Format("The associatedInterfaceType on the attribute '{0}' on the interface type '{1}' is null", typeof(DataAssociationAttribute), interfaceType)); List<Type> associatedTypes; Type associatedInterface = attribute.AssociatedInterfaceType; if (_associatedTypes.TryGetValue(associatedInterface, out associatedTypes) == false) { associatedTypes = new List<Type>(); _associatedTypes.Add(associatedInterface, associatedTypes); DataEventSystemFacade.SubscribeToDataAfterUpdate(associatedInterface, OnAfterDataUpdated, false); } associatedTypes.Add(interfaceType); PropertyInfo propertyInfo = (from pi in interfaceType.GetAllProperties() where pi.Name == attribute.ForeignKeyPropertyName select pi).FirstOrDefault(); if (propertyInfo == null) throw new ArgumentException(string.Format("The foreign key property name '{0}' set on the attribute '{1}' does not exist on the interface '{2}'", attribute.ForeignKeyPropertyName, typeof(DataAssociationAttribute), interfaceType)); var dataAssociationInfo = new DataAssociationInfo { AssociatedInterfaceType = associatedInterface, ForeignKeyPropertyName = attribute.ForeignKeyPropertyName, ForeignKeyPropertyInfo = propertyInfo, AssociationType = attribute.AssociationType, }; Verify.IsFalse(dataAssociationInfos.ContainsKey(associatedInterface), "Failed to register interface '{0}'. Data association already exist, type: '{1}'".FormatWith(interfaceType, associatedInterface)); dataAssociationInfos.Add(associatedInterface, dataAssociationInfo); if (!DataProviderRegistry.AllInterfaces.Contains(associatedInterface)) { Log.LogCritical("DataReferenceRegistry", string.Format("The one type '{0}' is associated to the non supported data type '{1}'", interfaceType, associatedInterface)); } } _dataAssociations.Add(interfaceType, dataAssociationInfos); }
private bool HasEntityTokenLockAttribute(Type workflowType) { bool hasEntityLockAttribute; if (!_hasEntityTokenLockAttributeCache.TryGetValue(workflowType, out hasEntityLockAttribute)) { hasEntityLockAttribute = workflowType.GetCustomAttributesRecursively<EntityTokenLockAttribute>().Any(); _hasEntityTokenLockAttributeCache.Add(workflowType, hasEntityLockAttribute); } return hasEntityLockAttribute; }
private void SetWorkflowPersistingType(Type workflowType, Guid instanceId) { List<AllowPersistingWorkflowAttribute> attributes = workflowType.GetCustomAttributesRecursively<AllowPersistingWorkflowAttribute>().ToList(); Verify.That(attributes.Count <= 1, "More than one attribute of type '{0}' found", typeof(AllowPersistingWorkflowAttribute).FullName); var persistenceType = attributes.Count == 1 ? attributes[0].WorkflowPersistingType : WorkflowPersistingType.Never; using (_resourceLocker.Locker) { _resourceLocker.Resources.WorkflowPersistingTypeDictionary.Add(instanceId, persistenceType); } }
public static ResourceHandle GetActionResourceHandle(Type elementProviderType, string actionTypeName) { Dictionary<string, ResourceHandle> actionResourceHandles; using (_resourceLocker.Locker) { if (_resourceLocker.Resources.ActionResourceHandleCache.TryGetValue(elementProviderType, out actionResourceHandles) == false) { actionResourceHandles = new Dictionary<string, ResourceHandle>(); var pairs = (from t in elementProviderType.GetCustomAttributesRecursively<ActionResourceHandleAttribute>() select new { ActionTypeName = t.ActionTypeName, ActionResourceHandle = t.ActionResourceHandle }); foreach (var pair in pairs) { if (actionResourceHandles.ContainsKey(pair.ActionTypeName) == false) { actionResourceHandles.Add(pair.ActionTypeName, pair.ActionResourceHandle); } } _resourceLocker.Resources.ActionResourceHandleCache.Add(elementProviderType, actionResourceHandles); } ResourceHandle actionResourceHandle; actionResourceHandles.TryGetValue(actionTypeName, out actionResourceHandle); return actionResourceHandle; } }