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;
}
}
