/// <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())); }