public OcLayerException(string message, [CanBeNull] Exception exception, string resourceName, OcLayerType layerType, string layerTypeName, IOcRequest request = null, [CanBeNull] Type entityType = null, [CanBeNull] object entity = null, [CanBeNull] object entityKey = null, [CallerMemberName] string callerName = null, [CallerFilePath] string callerFile = null, [CallerLineNumber] int callerLine = 0)
: base(string.IsNullOrWhiteSpace(message) ? "Unspecified Layer Routing Error" : message, exception, entityType, entity, entityKey, callerName, callerFile, callerLine)
{
ResourceName = resourceName;
if (ResourceName != null)
{
PropertySet(nameof(ResourceName), ResourceName);
}
LayerType = layerType;
if (LayerType != OcLayerType.Unknown)
{
PropertySet(nameof(LayerType), LayerType);
}
LayerTypeName = layerTypeName;
if (LayerTypeName != null)
{
PropertySet(nameof(LayerTypeName), LayerTypeName);
}
Request = request;
if (Request != null)
{
PropertySet(nameof(Request), Request);
}
}
/// <inheritdoc />
public IOcLayer <TRequest> GetResourceLayer([NotNull] string resourceName, OcLayerType layerType, [NotNull] TRequest request)
{
if (!_serviceLocator.IsAllowed(LayerType, layerType))
{
throw NewRoutingException(resourceName, layerType, null, $"Failed to get Resource [{resourceName}] because Layer [{LayerTypeName}] is not allowed to access Layer [{layerType}]");
}
return(_serviceLocator.GetResourceLayer(resourceName, layerType, request));
}
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;
}
public OcLayerRoutingException(string message, [CanBeNull] Exception exception, string resourceName, OcLayerType layerType, string layerTypeName, OcLayerType nextLayerType, string nextLayerTypeName, [CallerMemberName] string callerName = null, [CallerFilePath] string callerFile = null, [CallerLineNumber] int callerLine = 0)
: base(message, exception, resourceName, layerType, layerTypeName, null, null, null, null, callerName, callerFile, callerLine)
{
NextLayerType = nextLayerType;
if (NextLayerType != OcLayerType.Unknown)
{
PropertySet(nameof(NextLayerType), NextLayerType);
}
NextLayerTypeName = nextLayerTypeName;
if (NextLayerTypeName != null)
{
PropertySet(nameof(NextLayerTypeName), NextLayerTypeName);
}
}
/// <summary>
/// Returns true if <paramref name="layerType"/> is allowed in the system.
/// </summary>
public bool IsAllowed(OcLayerType layerType)
{
if (layerType == OcLayerType.Unknown)
{
return(false);
}
if (layerType == OcLayerType.Other)
{
return(_layerTypeNames.Count > 0);
}
using (var readLock = _layerTypes.ReadLock())
{
readLock.Lock();
// If no layer types have been configured as allowed, then allow all layer types.
return(_layerTypes.Count == 0 || _layerTypes.Contains(layerType));
}
}
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));
}
}
/// <summary>
/// Preferred constructor when <paramref name="layerType"/> is not <see cref="OcLayerType.Other"/>
/// It is better to have <paramref name="resourceName"/> specified manually than the alternative constructor that attempts to determine it programatically.
/// </summary>
/// <param name="layerType"></param>
/// <param name="configuration"></param>
/// <param name="resourceName"></param>
/// <param name="request"></param>
/// <param name="nextLayer"></param>
protected OcLayerAdapterReadBase([NotNull] IOcLayerConfiguration <TRequest> configuration, OcLayerType layerType, string resourceName, [NotNull] TRequest request, TNextLayer nextLayer)
: base(configuration, layerType, resourceName, request, nextLayer)
{
}
protected OcLayerLogicReadSearchBase([NotNull] IOcLayerConfiguration <TRequest> configuration, OcLayerType layerType, string resourceName, [NotNull] TRequest request)
: base(configuration, layerType, resourceName, request)
{
}
protected OcLayerException NewConstructorException(string message, [CanBeNull] Exception exception, string resourceName, OcLayerType layerType, string layerTypeName, IOcRequest request = null, [CallerMemberName] string callerName = null, [CallerFilePath] string callerFile = null, [CallerLineNumber] int callerLine = 0)
{
// ReSharper disable ExplicitCallerInfoArgument
var ex = new OcLayerException($"Error constructing {GetType().FriendlyName()}" + (string.IsNullOrWhiteSpace(message) ? "" : message), exception, resourceName, layerType, layerTypeName, request, null, null, null, callerName, callerFile, callerLine);
// ReSharper restore ExplicitCallerInfoArgument
Request.ResponseMessages.Add(OcApiMessageType.Error, $"Layer Constructor Exception: {ex.Summary}");
return(ex);
}
/// <summary>
/// Preferred constructor for use with <see cref="OcLayerType.Other"/> and specifying a <paramref name="layerTypeName"/>.
/// It is better to have <paramref name="resourceName"/> specified manually than the alternative constructor that attempts to determine it programatically.
/// </summary>
/// <param name="layerTypeName"></param>
/// <param name="configuration"></param>
/// <param name="resourceName"></param>
/// <param name="request"></param>
/// <param name="nextLayerType"></param>
/// <param name="nextLayerTypeName"></param>
protected OcLayerAdapterCrudBase([NotNull] IOcLayerConfiguration <TRequest> configuration, [NotNull] string layerTypeName, string resourceName, [NotNull] TRequest request, OcLayerType nextLayerType, string nextLayerTypeName)
: base(configuration, layerTypeName, resourceName, request, nextLayerType, nextLayerTypeName)
{
}
/// <inheritdoc /> public IOcLayerCrudSearch <TRequest, TEntity, TKey, TSearch> GetLayerCrudSearch <TEntity, TKey, TSearch>([NotNull] string resourceName, OcLayerType layerType, [NotNull] TRequest request) where TEntity : class where TSearch : class => GetResourceLayer(resourceName, layerType, request) as IOcLayerCrudSearch <TRequest, TEntity, TKey, TSearch>;
/// <inheritdoc /> public IOcLayerRead <TRequest, TEntity, TKey> GetLayerRead <TEntity, TKey>([NotNull] string resourceName, OcLayerType layerType, [NotNull] TRequest request) where TEntity : class => GetResourceLayer(resourceName, layerType, request) as IOcLayerRead <TRequest, TEntity, TKey>;
protected OcLayerRoutingException NewRoutingException(string resourceName, OcLayerType nextLayerType, string nextLayerTypeName, string message, [CanBeNull] Exception exception = null, [CallerMemberName] string callerName = null, [CallerFilePath] string callerFile = null, [CallerLineNumber] int callerLine = 0)
{
// ReSharper disable ExplicitCallerInfoArgument
return(new OcLayerRoutingException(message, exception, resourceName, LayerType, LayerTypeName, nextLayerType, nextLayerTypeName, callerName, callerFile, callerLine));
// ReSharper restore ExplicitCallerInfoArgument
}
protected OcLayerApiCrudSearchBase([NotNull] IOcLayerConfiguration <TRequest> configuration, OcLayerType layerType, string resourceName, [NotNull] TRequest request, TNext nextLayer)
: base(configuration, layerType, resourceName, request, nextLayer)
{
}
protected OcLayerLogicCrudBase([NotNull] IOcLayerConfiguration <TRequest> configuration, OcLayerType layerType, string resourceName, [NotNull] TRequest request, OcLayerType nextLayerType)
: base(configuration, layerType, resourceName, request, nextLayerType)
{
}
/// <summary>
/// Preferred constructor when <paramref name="layerType"/> is not <see cref="OcLayerType.Other"/>
/// It is better to have <paramref name="resourceName"/> specified manually than the alternative constructor that attempts to determine it programatically.
/// </summary>
/// <param name="layerType"></param>
/// <param name="configuration"></param>
/// <param name="resourceName"></param>
/// <param name="request"></param>
/// <param name="nextLayerType"></param>
protected OcLayerAdapterBase([NotNull] IOcLayerConfiguration <TRequest> configuration, OcLayerType layerType, string resourceName, [NotNull] TRequest request, OcLayerType nextLayerType)
: base(configuration, layerType, resourceName, request, nextLayerType)
{
DataMapper = configuration.DataMapper;
if (DataMapper == null)
{
throw NewConstructorException($"{nameof(DataMapper)} not available from {nameof(configuration)}", null, resourceName, layerType, null, request);
}
}
/// <summary>
/// If available returns the specified interface to the layer that provides <paramref name="layerType"/> services for <paramref name="resourceName"/>.
/// Returns null if a suitable resource layer could not be found.
/// </summary>
/// <typeparam name="TLayer">The interface (which inherits from <see cref="IOcLayer{TRequest}"/> being sought.</typeparam>
/// <param name="resourceName">Name of the resource that they layer provides access to</param>
/// <param name="layerType">Type of layer to search for</param>
protected virtual TLayer GetLayer <TLayer>(string resourceName, OcLayerType layerType) where TLayer : class, IOcLayer <TRequest>
{
return(Factory.GetResourceLayer(resourceName, layerType, Request) as TLayer);
}
/// <summary>
/// Returns true if the specified layer type is allowed in the system.
/// Note that if <see cref="OcLayerType.Other"/> is specified then <paramref name="layerTypeName"/> must have a value.
/// </summary>
public bool IsAllowed(OcLayerType layerType, string layerTypeName)
{
return(layerType == OcLayerType.Other ? IsAllowed(layerTypeName) : IsAllowed(layerType));
}
/// <summary>
/// Alternative constructor for when <paramref name="layerType"/> is not <see cref="OcLayerType.Other"/>
/// When possible it is better to use the other, preferred constructor and specify the <see cref="ResourceName"/> rather than attempting to determine it programatically.
/// </summary>
/// <param name="layerType"></param>
/// <param name="configuration"></param>
/// <param name="request"></param>
protected OcLayerBase([NotNull] IOcLayerConfiguration <TRequest> configuration, OcLayerType layerType, [NotNull] TRequest request)
: this(configuration, layerType, null, null, request)
{
}
/// <summary>
/// Returns true if <paramref name="fromLayerType"/> is allowed to access <paramref name="toLayerType"/>.
/// 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, OcLayerType toLayerType)
{
return(IsAllowed(fromLayerType, null, toLayerType, null));
}
protected OcLayerRepositoryCrudBase([NotNull] IOcLayerConfiguration <TRequest> configuration, OcLayerType layerType, string resourceName, [NotNull] TRequest request)
: base(configuration, layerType, resourceName, request)
{
}
protected OcLayerLogicBase([NotNull] IOcLayerConfiguration <TRequest> configuration, OcLayerType layerType, string resourceName, [NotNull] TRequest request)
: base(configuration, layerType, resourceName, request)
{
AuthorizationService = configuration.AuthorizationService;
}
