internal OcLayerRestrictedCrudFactory(OcLayerType layerType, OcLayerConfiguration <TRequest> serviceLocator)
{
if (layerType == OcLayerType.Unknown || layerType == OcLayerType.Other)
{
throw new ArgumentOutOfRangeException(nameof(layerType));
}
if (serviceLocator == null)
{
throw new ArgumentNullException(nameof(serviceLocator));
}
LayerType = layerType;
LayerTypeName = LayerType.ToString();
_serviceLocator = serviceLocator;
}
private OcLayerBase([NotNull] IOcLayerConfiguration <TRequest> configuration, OcLayerType layerType, string layerTypeName, string resourceName, [NotNull] TRequest request)
{
if (configuration == null)
{
throw new ArgumentNullException(nameof(configuration));
}
if (layerType == OcLayerType.Unknown)
{
throw new ArgumentOutOfRangeException(nameof(layerType), layerType, $"{nameof(layerType)} can not be {nameof(OcLayerType.Unknown)}");
}
if (layerType == OcLayerType.Other && string.IsNullOrWhiteSpace(layerTypeName))
{
throw new ArgumentOutOfRangeException(nameof(layerType), layerType, $"{nameof(layerTypeName)} must be specified for {nameof(OcLayerType.Other)}");
}
if (layerType != OcLayerType.Other && layerTypeName != null)
{
throw new ArgumentOutOfRangeException(nameof(layerType), layerType, $"{nameof(layerTypeName)} must be null unless {nameof(layerType)} is {nameof(OcLayerType.Other)}");
}
if (request == null)
{
throw new ArgumentNullException(nameof(request));
}
if (!configuration.IsAllowed(layerType, layerTypeName))
{
throw new ArgumentOutOfRangeException(nameof(layerType), $"Layers of LayerType [{layerType}] and LayerTypeName [{layerTypeName}] are not allowed in this systems");
}
InstanceId = Interlocked.Increment(ref _globalInstanceCounter);
LayerType = layerType;
LayerTypeName = LayerType == OcLayerType.Other ? LayerType.ToString() : layerTypeName?.Trim();
Debug.Assert(!string.IsNullOrWhiteSpace(LayerTypeName));
ResourceName = DetermineResourceName(resourceName, LayerTypeName, GetType());
Request = request;
Factory = configuration.RestrictedFactoryCrud(LayerType, LayerTypeName);
Debug.Assert(Factory != null);
Log?.WriteLine($"LAYER CREATE - InstanceID [{InstanceId}] Type [{GetType().FriendlyName()}] Resource [{ResourceName}] LayerTypeName [{LayerTypeName}]");
}
/// <summary>
/// Returns true if the From Layer Type is allowed to access the To Layer Type.
/// Note that if no layer interaction restrictions have been configured then any valid layer is allowed to interact with any other valid layer.
/// </summary>
public bool IsAllowed(OcLayerType fromLayerType, string fromLayerTypeName, OcLayerType toLayerType, string toLayerTypeName)
{
if (fromLayerType == OcLayerType.Unknown || toLayerType == OcLayerType.Unknown)
{
return(false);
}
if (fromLayerType == OcLayerType.Other && string.IsNullOrWhiteSpace(fromLayerTypeName))
{
throw new ArgumentNullException(nameof(fromLayerTypeName));
}
if (toLayerType == OcLayerType.Other && string.IsNullOrWhiteSpace(toLayerTypeName))
{
throw new ArgumentNullException(nameof(toLayerTypeName));
}
if (fromLayerType != OcLayerType.Other)
{
fromLayerTypeName = fromLayerType.ToString();
}
if (toLayerType != OcLayerType.Other)
{
toLayerTypeName = toLayerType.ToString();
}
using (var readLock = _layerNameInteractions.ReadLock())
{
readLock.Lock();
// If restrictions have been configured use them to answer the question
if (_layerNameInteractions.TryGetValue(fromLayerTypeName, out var allowed))
{
return(allowed?.Contains(toLayerTypeName) ?? false);
}
// If restrictions are not configured, assume any type of interaction is allowed (assuming the from layer type is allowed by the system).
return(IsAllowed(fromLayerType, fromLayerTypeName) && IsAllowed(toLayerType, toLayerTypeName));
}
}
