/// <summary>
/// Merges specs from a part of the entity or serve into the current instance.
/// </summary>
/// <typeparam name="TPart">The complex part type to evaluate.</typeparam>
/// <param name="partGetter">Function to get the part instance.</param>
/// <param name="source"></param>
public void MergeFrom <TPart>(Func <TEntityOrService, TPart> partGetter, IProvideSpecifications <TPart> source)
{
foreach (var specification in source.GetSpecifications())
{
Add(a => specification.Evaluate(partGetter(a)), specification.Key, specification.Description);
}
}
public SoftwareModelService(
FsUnitOfWork db,
FSSecurityContext securityContext,
ReferenceProvider referenceService,
BusinessUnitProvider businessUnitService,
CapabilityProvider capabilityProvider,
ProjectService projectService,
StakeholderService stakeholderService,
SoftwareModelInterfaceService softwareModelInterfaceService,
ProviderLinq <SoftwareModelDependency, Guid> softwareModelDependencyProvider,
IEntityIdProvider <SoftwareModel, Guid> idProvider,
IMessagePipe messagePipe = null,
IProvideSpecifications <SoftwareModel> specProvider = null,
EntityHandler <SoftwareModel, Guid> entityHandler = null)
: base(securityContext, referenceService, db, idProvider, messagePipe, specProvider, entityHandler)
{
Guard.ArgumentNotNull(securityContext, nameof(securityContext));
Guard.ArgumentNotNull(capabilityProvider, nameof(capabilityProvider));
Guard.ArgumentNotNull(referenceService, nameof(referenceService));
Guard.ArgumentNotNull(softwareModelInterfaceService, nameof(softwareModelInterfaceService));
_sfDb = db;
_capabilitiesProvider = capabilityProvider;
_businessUnitService = businessUnitService;
_stakeholderService = stakeholderService;
_softwareModelInterfaceService = softwareModelInterfaceService;
_softwareModelDependencyService = softwareModelDependencyProvider;
_projectService = projectService;
}
/// <summary>
/// Raises a <see cref="RuleException" /> if the entity tested has errors.
/// </summary>
public static void ThrowExceptionIfInvalid <TEntity>(
this IProvideSpecifications <TEntity> specProvider,
TEntity entity,
string exceptionMessageText,
string category = null)
{
ThrowExceptionIfInvalid(specProvider.GetSpecifications(), entity, category);
}
public ProtocolTypeProvider(
IUnitOfWorkLinq <ProtocolType, string> db,
IEntityIdProvider <ProtocolType, string> idProvider,
IMessagePipe messagePipe = null,
IProvideSpecifications <ProtocolType> specProvider = null,
EntityHandler <ProtocolType, string> entityHandler = null) :
base(db, idProvider, messagePipe, specProvider, entityHandler)
{
}
/// <summary>
/// Creates a new instance.
/// </summary>
public ScenarioProvider(
IUnitOfWorkLinq <Scenario, Guid> db,
IEntityIdProvider <Scenario, Guid> keyBinder,
IMessagePipe messagePipe = null,
IProvideSpecifications <Scenario> specProvider = null,
EntityHandler <Scenario, Guid> entityHandler = null)
: base(db, keyBinder, messagePipe, specProvider, entityHandler)
{
}
/// <summary>
/// Creates a new instance.
/// </summary>
public CapabilityProvider(
IUnitOfWorkLinq <Capability, Guid> db,
IEntityIdProvider <Capability, Guid> keyBinder,
IMessagePipe messagePipe = null,
IProvideSpecifications <Capability> specProvider = null,
EntityHandler <Capability, Guid> entityHandler = null)
: base(db, keyBinder, messagePipe, specProvider, entityHandler)
{
}
public StakeholderLoginProvider(
IUnitOfWorkLinq <StakeholderLogin, Guid> db,
IEntityIdProvider <StakeholderLogin, Guid> keyBinder,
IMessagePipe messagePipe = null,
IProvideSpecifications <StakeholderLogin> specProvider = null,
EntityHandler <StakeholderLogin, Guid> entityHandler = null)
: base(db, keyBinder, messagePipe, specProvider, entityHandler)
{
}
public BusinessUnitProvider(
IUnitOfWorkLinq <BusinessUnit, Guid> db,
IEntityIdProvider <BusinessUnit, Guid> keyBinder,
IMessagePipe messagePipe = null,
IProvideSpecifications <BusinessUnit> specProvider = null,
EntityHandler <BusinessUnit, Guid> entityHandler = null)
: base(db, keyBinder, messagePipe, specProvider, entityHandler)
{
}
public LifeCycleProvider(
IUnitOfWorkLinq <LifeCycle, string> db,
IEntityIdProvider <LifeCycle, string> keyBinder,
IMessagePipe messagePipe = null,
IProvideSpecifications <LifeCycle> specProvider = null,
EntityHandler <LifeCycle, string> onBeforeInsert = null)
: base(db, keyBinder, messagePipe, specProvider, onBeforeInsert)
{
}
public MaybeLoader(
ProviderLinq <MaybeEntity, int> provider,
IProvideSpecifications <MaybeLoaderDto> rulesProvider,
IExtractor <MaybeLoaderDto> extractor)
: base(
extractor ?? new CsvExtractor <MaybeLoaderDto>(),
rulesProvider,
"MaybeEntity")
{
_provider = provider;
}
/// <summary>
/// Aggregates the specifications/rules from another spec provider into the current instance.
/// </summary>
/// <param name="specProvider">
/// The other specification provider for the entity or service.
/// </param>
public SpecProvider <TEntityOrService> Add(IProvideSpecifications <TEntityOrService> specProvider)
{
Guard.ArgumentNotNull(specProvider, nameof(specProvider));
foreach (var spec in specProvider.GetSpecifications())
{
_specs.Add(spec);
}
return(this);
}
public PolicyProvider(
IUnitOfWorkLinq <Policy, Guid> db,
ReferenceProvider referencesProvider,
IEntityIdProvider <Policy, Guid> idProvider,
IMessagePipe messagePipe = null,
IProvideSpecifications <Policy> specProvider = null,
EntityHandler <Policy, Guid> entityHandler = null) :
base(db, idProvider, messagePipe, specProvider, entityHandler)
{
_referencesProvider = referencesProvider;
_db = db;
}
public ApplicationAccessService(
FsUnitOfWork db,
DeviceService deviceService,
IEntityIdProvider <ApplicationAccess, Guid> keyBinder,
IMessagePipe messagePipe = null,
IProvideSpecifications <ApplicationAccess> specProvider = null,
EntityHandler <ApplicationAccess, Guid> entityHandler = null)
: base(db, keyBinder, messagePipe, specProvider, entityHandler)
{
_deviceService = deviceService;
_db = db;
}
/// <summary>
/// Creates a new instance.
/// </summary>
/// <param name="db">The references database.</param>
/// <param name="keyBinder"></param>
/// <param name="messagePipe"></param>
/// <param name="referencesSpec">Rules to validate a given reference entity.</param>
public ReferenceProvider(
IUnitOfWorkLinq <Reference, Guid> db,
IEntityIdProvider <Reference, Guid> keyBinder,
IMessagePipe messagePipe,
IProvideSpecifications <Reference> referencesSpec = null,
EntityHandler <Reference, Guid> entityHandler = null)
: base(db, keyBinder, messagePipe, referencesSpec, entityHandler)
{
Guard.ArgumentNotNull(db, nameof(db));
_db = db;
}
/// <summary>
/// Creates a new generic service to add/update valid entities and/or remove them from the application.
/// </summary>
/// <param name="messagePipe">Message pipe to dispatch domain events.</param>
/// <param name="db">The data store to use to persist the entity.</param>
/// <param name="idProvider">Function to get a new key for a given entity.</param>
/// <param name="specProvider">
/// The custom rule provider to use to validate entities added/updated to the service. By
/// default service will use data annotations to build business rules to validate the object.
/// </param>
/// <param name="handler">A handler to use to process entities being added/removed or activated through the provider.</param>
public ProviderLinq(
IUnitOfWorkLinq <TEntity, TKey> db,
IKeyProvider <TEntity, TKey> idProvider,
IMessagePipe messagePipe = null,
IProvideSpecifications <TEntity> specProvider = null,
EntityHandler <TEntity, TKey> handler = null)
{
Guard.ArgumentNotNull(db, nameof(db));
Guard.ArgumentNotNull(messagePipe, nameof(messagePipe));
Db = db;
MessagePipe = messagePipe ?? new NoOpMessagePipe();
_idProvider = idProvider;
// wrap processors
// ----------------------------------------------------
_onBeforeDelete = new Stack <Action <TKey> >();
_onBeforeInsert = new Stack <Action <TEntity> >();
_onInitialize = new Stack <Action <TEntity> >();
if (handler != null)
{
if (handler.RemoveHandler != null)
{
OnRemoving(handler.RemoveHandler.Handle);
}
if (handler.AddHandler != null)
{
OnAdding(handler.AddHandler.Handle);
}
if (handler.ActivateHandler != null)
{
OnInitializing(handler.ActivateHandler.Handle);
}
}
// ---------------------------------------------------
//assign specs
// ReSharper disable once ConvertIfStatementToConditionalTernaryExpression
if (specProvider != null)
{
_specs = specProvider.GetSpecifications().ToList();
}
else
{
_specs = _defaultSpecs;
}
}
public ProjectService(
ScenarioProvider scenarioProvider,
BusinessUnitProvider businessUnitProvider,
FsUnitOfWork db,
IEntityIdProvider <Project, Guid> idProvider,
IProvideSpecifications <Project> specProvider = null,
EntityHandler <Project, Guid> entityHandler = null)
: base(db, idProvider, scenarioProvider?.MessagePipe, specProvider, entityHandler)
{
_db = db;
_scenarioProvider = scenarioProvider;
_businessUnitProvider = businessUnitProvider;
}
public DesignDomainService(
FsUnitOfWork db,
PolicyProvider policyProvider,
ReferenceProvider referencesProvider,
IEntityIdProvider <DesignDomain, Guid> keyBinder,
IMessagePipe messagePipe = null,
IProvideSpecifications <DesignDomain> specProvider = null,
EntityHandler <DesignDomain, Guid> entityHandler = null)
: base(db, keyBinder, messagePipe, specProvider, entityHandler)
{
_referenceService = referencesProvider;
_fsDb = db;
_policyProvider = policyProvider;
}
/// <summary>
/// Creates a new instance.
/// </summary>
/// <param name="db">The references database.</param>
/// <param name="idProvider"></param>
/// <param name="messagePipe"></param>
/// <param name="referencesSpec">Rules to validate a given reference entity.</param>
public UserGroupService(
FsUnitOfWork db,
StakeholderService stakeholderService,
IEntityIdProvider <UserGroup, Guid> idProvider,
IMessagePipe messagePipe,
IProvideSpecifications <UserGroup> referencesSpec = null,
EntityHandler <UserGroup, Guid> entityHandler = null)
: base(db, idProvider, messagePipe, referencesSpec, entityHandler)
{
Guard.ArgumentNotNull(db, nameof(db));
_stakeholderService = stakeholderService;
_db = db;
}
public ProtocolService(
FSSecurityContext securityContext,
ProjectService projectService,
StakeholderService stakeholderService,
ReferenceProvider referenceService,
UnitOfWorkLinq <Protocol, Guid> db,
IEntityIdProvider <Protocol, Guid> idProvider,
IMessagePipe messagePipe = null,
IProvideSpecifications <Protocol> specProvider = null,
EntityHandler <Protocol, Guid> entityHandler = null) :
base(securityContext, referenceService, db, idProvider, messagePipe, specProvider, entityHandler)
{
_scenarioProvider = projectService;
_stakeholderService = stakeholderService;
}
public SoftwareModelInterfaceService(
FSSecurityContext securityContext,
ReferenceProvider referencesProvider,
ProtocolService protocolService,
ProjectService projectService,
UnitOfWorkLinq <SoftwareModelInterface, Guid> db,
IEntityIdProvider <SoftwareModelInterface, Guid> idProvider,
IMessagePipe messagePipe = null,
IProvideSpecifications <SoftwareModelInterface> specProvider = null,
EntityHandler <SoftwareModelInterface, Guid> entityHandler = null) : base(securityContext, referencesProvider, db, idProvider, messagePipe, specProvider, entityHandler)
{
Guard.ArgumentNotNull(protocolService, nameof(protocolService));
_protocolService = protocolService;
_projectService = projectService;
}
public PolicyService(
FsUnitOfWork db,
DesignDomainService designDomainService,
ReferenceProvider referencesProvider,
IEntityIdProvider <Policy, Guid> keyBinder,
IMessagePipe messagePipe = null,
IProvideSpecifications <Policy> specProvider = null,
EntityHandler <Policy, Guid> entityHandler = null)
: base(db, keyBinder, messagePipe, specProvider, entityHandler)
{
Guard.ArgumentNotNull(referencesProvider, nameof(referencesProvider));
_referenceService = referencesProvider;
_fsDb = db;
_designDomainService = designDomainService;
}
/// <summary>
/// Creates a new instance.
/// </summary>
/// <param name="specProviderForEntity"></param>
/// <param name="specProviderForEntityCollection"></param>
/// <param name="mapper">The mapper to use to map incoming entities to outgoing entities.</param>
public ProcessorConfiguration(
IProvideSpecifications <TEntityOut> specProviderForEntity,
IProvideSpecifications <IEnumerable <TEntityOut> > specProviderForEntityCollection,
ObjectsMapper <TEntityIn, TEntityOut> mapper = null)
{
Guard.ArgumentNotNull(specProviderForEntity, nameof(specProviderForEntity));
Guard.ArgumentNotNull(specProviderForEntityCollection, nameof(specProviderForEntityCollection));
_specProviderForEntity = specProviderForEntity;
_specProviderForEntityCollection = specProviderForEntityCollection;
Mapper = mapper ?? ObjectMapperManager.DefaultInstance.GetMapper <TEntityIn, TEntityOut>();
// define the input and output target data
_outDirectory = Environment.CurrentDirectory;
_inDirectory = Environment.CurrentDirectory;
}
public FsService(
FSSecurityContext securityContext,
ReferenceProvider referenceProvider,
IUnitOfWorkLinq <TEntity, Guid> db,
IEntityIdProvider <TEntity, Guid> idProvider,
IMessagePipe messagePipe = null,
IProvideSpecifications <TEntity> specProvider = null,
EntityHandler <TEntity, Guid> entityHandler = null) :
base(db, idProvider, messagePipe, specProvider, entityHandler)
{
Guard.ArgumentNotNull(db, nameof(db));
Guard.ArgumentNotNull(referenceProvider, nameof(referenceProvider));
Guard.ArgumentNotNull(securityContext, nameof(securityContext));
_securityContext = securityContext;
this.referenceProvider = referenceProvider;
}
/// <summary>
/// Creates a new instance.
/// </summary>
/// <param name="loaderTypeCode">The type of entity that is being loaded into the system.</param>
/// <param name="validator">Validates the incoming dtos.</param>
/// <param name="extractor">The underlying extrator for the incoming dtos.</param>
protected LoaderBaseWithState(
IExtractor <TDtoIn> extractor = null,
IProvideSpecifications <TDtoIn> validator = null,
string loaderTypeCode = null)
{
LoaderTypeCode = loaderTypeCode ?? typeof(TLoadStateData).Name;
_validator = validator;
_logger = LogManager.GetLogger(loaderTypeCode);
// create default extractor function
if (extractor == null)
{
extractor = new CsvExtractor <TDtoIn>();
}
_extractor = extractor;
}
/// <summary>
/// Creates a new instance given a set of primitive services.
/// </summary>
public NetworkService(
FSSecurityContext securityContext,
ReferenceProvider referenceProvider,
BusinessUnitProvider businessUnitProvider,
StakeholderService stakeholdersService,
ProtocolService protocolService,
DeviceModelService deviceModelService,
DeviceService deviceService,
DeviceConnectionService deviceConnectionService,
ApplicationAccessService appAccessService,
ProjectService projectService,
FsUnitOfWork db,
IEntityIdProvider <Network, Guid> idProvider,
IMessagePipe messagePipe = null,
IProvideSpecifications <Network> specProvider = null,
EntityHandler <Network, Guid> entityHandler = null) : base(securityContext, referenceProvider, db, idProvider, messagePipe, specProvider, entityHandler)
{
Guard.ArgumentNotNull(stakeholdersService, nameof(stakeholdersService));
Guard.ArgumentNotNull(protocolService, nameof(protocolService));
Guard.ArgumentNotNull(deviceService, nameof(deviceService));
Guard.ArgumentNotNull(deviceConnectionService, nameof(deviceConnectionService));
Guard.ArgumentNotNull(deviceModelService, nameof(deviceModelService));
Guard.ArgumentNotNull(projectService, nameof(projectService));
Guard.ArgumentNotNull(businessUnitProvider, nameof(businessUnitProvider));
Guard.ArgumentNotNull(appAccessService, nameof(appAccessService));
// compose device service
// todo: dependency inject
//setup and configure service
_deviceService = deviceService;
_appAccessService = appAccessService;
_businessUnitService = businessUnitProvider;
_projectService = projectService;
_deviceModelService = deviceModelService;
_protocolService = protocolService;
_deviceConnectionService = deviceConnectionService;
_stakeholderService = stakeholdersService;
_db = db;
}
//.ctor
public StakeholderService(
FSSecurityContext securityContext,
ProjectService projectService,
BusinessUnitProvider businessUnitProvider,
StakeholderLoginProvider stakeholderLoginProvider,
ReferenceProvider referencesProvider,
FsUnitOfWork db,
IMessagePipe messagePipe,
IEntityIdProvider <Stakeholder, Guid> idProvider,
IProvideSpecifications <Stakeholder> specProvider = null,
EntityHandler <Stakeholder, Guid> entityHandler = null)
: base(securityContext, referencesProvider, db, idProvider, messagePipe, specProvider, entityHandler)
{
Guard.ArgumentNotNull(projectService, nameof(projectService));
Guard.ArgumentNotNull(stakeholderLoginProvider, nameof(stakeholderLoginProvider));
_db = db;
_projectService = projectService;
_businessUnitProvider = businessUnitProvider;
_stakeholderLoginProvider = stakeholderLoginProvider;
}
public DeviceConnectionService(
FSSecurityContext securityContext,
ReferenceProvider referenceService,
StakeholderService stakeholderService,
UserGroupService userGroupService,
ProjectService projectService,
UnitOfWorkLinq <DeviceConnection, Guid> db,
DeviceService deviceService,
ProtocolService protocolService,
IEntityIdProvider <DeviceConnection, Guid> keyBinder,
IMessagePipe messagePipe = null,
IProvideSpecifications <DeviceConnection> specProvider = null,
EntityHandler <DeviceConnection, Guid> entityHandler = null)
: base(securityContext, referenceService, db, keyBinder, messagePipe, specProvider, entityHandler)
{
Guard.ArgumentNotNull(stakeholderService, nameof(stakeholderService));
Guard.ArgumentNotNull(userGroupService, nameof(userGroupService));
_deviceService = deviceService;
_protocolService = protocolService;
_projectService = projectService;
_userGroupService = userGroupService;
_stakeholderService = stakeholderService;
}
/// <summary>
/// Creates a new instance.
/// </summary>
/// <param name="validator">
/// Optional validator to use. Null will use 'SpecProvider'
/// </param>
/// <param name="log">The log to post event to.</param>
public DataSourceProcessor(IProvideSpecifications <TEntityDtoIn> validator = null, ILoaderLogWriter log = null)
{
_validator = validator ?? new SpecProvider <TEntityDtoIn>();
Log = Log ?? new LoaderLogWriter(LogManager.GetLogger(GetLogSystemName()));
}
