public GlobalCollectorJob(IBulkRepository bulkRepository, ILifetimeScope container, ILogger <GlobalCollectorJob> logger, ISchedulerCollectorConfigurationService schedulerCollectorConfigurationService)
{
_bulkRepository = bulkRepository;
_container = container;
_logger = logger;
_schedulerCollectorConfigurationService = schedulerCollectorConfigurationService;
}
// TODO {all, 15.09.2015}: Имеет смысл избавить *Processor от зависимостей IQuery, I*Info, заменить на DataChangesDetector
public ValueObjectProcessor(ValueObjectMetadataElement <T> metadata, IQuery query, IBulkRepository <T> repository, IEqualityComparerFactory equalityComparerFactory)
{
_metadata = metadata;
_repository = repository;
_equalityComparerFactory = equalityComparerFactory;
_changesDetector = new DataChangesDetector <T, T>(_metadata.MapSpecificationProviderForSource, _metadata.MapSpecificationProviderForTarget, query);
}
protected EntityActorBase(IQuery query,
IBulkRepository <TDataObject> bulkRepository,
IEqualityComparerFactory equalityComparerFactory,
IStorageBasedDataObjectAccessor <TDataObject> storageBasedDataObjectAccessor)
: this(query, bulkRepository, equalityComparerFactory, storageBasedDataObjectAccessor, new NullDataChangesHandler <TDataObject>())
{
}
public OrderAggregateRootActor(
IQuery query,
IEqualityComparerFactory equalityComparerFactory,
IBulkRepository <Order> bulkRepository,
IBulkRepository <Order.FirmOrganizationUnitMismatch> invalidFirmRepository,
IBulkRepository <Order.InvalidFirm> orderInvalidFirmRepository,
IBulkRepository <Order.PartnerPosition> partnerPositionRepository,
IBulkRepository <Order.PremiumPartnerPosition> premiumPartnerPositionRepository,
IBulkRepository <Order.FmcgCutoutPosition> fmcgCutoutPositionRepository,
IBulkRepository <Order.AddressAdvertisementNonOnTheMap> addressAdvertisementRepository,
IBulkRepository <Order.MissingValidPartnerFirmAddresses> missingValidPartnerFirmAddressesRepository,
IBulkRepository <Order.InvalidFirmAddress> orderInvalidFirmAddressRepository,
IBulkRepository <Order.InvalidCategory> invalidCategoryRepository,
IBulkRepository <Order.CategoryNotBelongsToAddress> categoryNotBelongsToAddress)
: base(query, equalityComparerFactory)
{
HasRootEntity(new OrderAccessor(query),
bulkRepository,
HasValueObject(new OrderFirmOrganizationUnitMismatchAccessor(query), invalidFirmRepository),
HasValueObject(new OrderInvalidFirmAccessor(query), orderInvalidFirmRepository),
HasValueObject(new PartnerPositionAccessor(query), partnerPositionRepository),
HasValueObject(new PremiumPartnerPositionAccessor(query), premiumPartnerPositionRepository),
HasValueObject(new FmcgCutoutPositionAccessor(query), fmcgCutoutPositionRepository),
HasValueObject(new AddressAdvertisementNonOnTheMapAccessor(query), addressAdvertisementRepository),
HasValueObject(new MissingValidPartnerFirmAddressesAccessor(query), missingValidPartnerFirmAddressesRepository),
HasValueObject(new InvalidFirmAddressAccessor(query), orderInvalidFirmAddressRepository),
HasValueObject(new InvalidCategoryAccessor(query), invalidCategoryRepository),
HasValueObject(new CategoryNotBelongsToAddressAccessor(query), categoryNotBelongsToAddress));
}
/// <summary>
/// Initializes a new instance of the <see cref="SimpleDataflowTask{TSource, TTarget}"/> class.
/// </summary>
/// <param name="source">Source sequence.</param>
/// <param name="map">Mapping function.</param>
/// <param name="destination">Destination repository.</param>
public SimpleDataflowTask(
IEnumerable <TSource> source,
Func <TSource, TTarget> map,
IBulkRepository <TTarget> destination)
: this(TaskBase.NextTaskName(), source, map, destination)
{
}
/// <summary>
/// Initializes a new instance of the <see cref="SimpleDataflowTask{TSource, TTarget}"/> class.
/// </summary>
/// <param name="name">Task name.</param>
/// <param name="source">Source sequence.</param>
/// <param name="map">Mapping function.</param>
/// <param name="destination">Destination repository.</param>
public SimpleDataflowTask(
string name,
IEnumerable <TSource> source,
Func <TSource, TTarget> map,
IBulkRepository <TTarget> destination)
: base(name)
{
if (source == null)
{
throw new ArgumentNullException("source");
}
if (map == null)
{
throw new ArgumentNullException("map");
}
if (destination == null)
{
throw new ArgumentNullException("destination");
}
this.source = source;
this.map = map;
this.destination = destination;
}
public OrderAggregateRootActor(
IQuery query,
IEqualityComparerFactory equalityComparerFactory,
IBulkRepository <Order> bulkRepository,
IBulkRepository <Order.BargainSignedLaterThanOrder> orderBargainSignedLaterThanOrderRepository,
IBulkRepository <Order.HasNoAnyLegalPersonProfile> orderHasNoAnyLegalPersonProfileRepository,
IBulkRepository <Order.HasNoAnyPosition> orderHasNoAnyPositionRepository,
IBulkRepository <Order.InactiveReference> inactiveReferenceRepository,
IBulkRepository <Order.InvalidBillsTotal> orderInvalidBillsTotalRepository,
IBulkRepository <Order.LegalPersonProfileBargainExpired> orderLegalPersonProfileBargainEndDateIsEarlierThanOrderSignupDateRepository,
IBulkRepository <Order.LegalPersonProfileWarrantyExpired> orderLegalPersonProfileWarrantyEndDateIsEarlierThanOrderSignupDateRepository,
IBulkRepository <Order.MissingBargainScan> orderMissingBargainScanRepository,
IBulkRepository <Order.MissingBills> orderMissingBillsRepository,
IBulkRepository <Order.MissingRequiredField> orderMissingRequiredFieldRepository,
IBulkRepository <Order.MissingOrderScan> orderMissingOrderScanRepository)
: base(query, equalityComparerFactory)
{
HasRootEntity(new OrderAccessor(query), bulkRepository,
HasValueObject(new OrderBargainSignedLaterThanOrderAccessor(query), orderBargainSignedLaterThanOrderRepository),
HasValueObject(new OrderHasNoAnyLegalPersonProfileAccessor(query), orderHasNoAnyLegalPersonProfileRepository),
HasValueObject(new OrderHasNoAnyPositionAccessor(query), orderHasNoAnyPositionRepository),
HasValueObject(new InactiveReferenceAccessor(query), inactiveReferenceRepository),
HasValueObject(new OrderInvalidBillsTotalAccessor(query), orderInvalidBillsTotalRepository),
HasValueObject(new LegalPersonProfileBargainExpiredAccessor(query), orderLegalPersonProfileBargainEndDateIsEarlierThanOrderSignupDateRepository),
HasValueObject(new LegalPersonProfileWarrantyExpiredAccessor(query), orderLegalPersonProfileWarrantyEndDateIsEarlierThanOrderSignupDateRepository),
HasValueObject(new OrderMissingBargainScanAccessor(query), orderMissingBargainScanRepository),
HasValueObject(new OrderMissingBillsAccessor(query), orderMissingBillsRepository),
HasValueObject(new MissingRequiredFieldAccessor(query), orderMissingRequiredFieldRepository),
HasValueObject(new OrderMissingOrderScanAccessor(query), orderMissingOrderScanRepository));
}
public StatisticsProcessor(StatisticsRecalculationMetadata <T, StatisticsKey> metadata, IQuery query, IBulkRepository <T> repository, IEqualityComparerFactory equalityComparerFactory)
{
_repository = repository;
_metadata = metadata;
_equalityComparerFactory = equalityComparerFactory;
_changesDetector = new DataChangesDetector <T>(_metadata.MapSpecificationProviderForSource, _metadata.MapSpecificationProviderForTarget, _equalityComparerFactory.CreateCompleteComparer <T>(), query);
}
public AggregateProcessor(DataChangesDetector <T> aggregateChangesDetector, IBulkRepository <T> repository, IReadOnlyCollection <IValueObjectProcessor> valueObjectProcessors, IFindSpecificationProvider <T, AggregateOperation> findSpecificationProvider)
{
_repository = repository;
_aggregateChangesDetector = aggregateChangesDetector;
_valueObjectProcessors = valueObjectProcessors;
_findSpecificationProvider = findSpecificationProvider;
}
public AggregateProcessor(AggregateMetadata <T> metadata, IValueObjectProcessorFactory valueObjectProcessorFactory, IQuery query, IBulkRepository <T> repository)
{
_metadata = metadata;
_query = query;
_repository = repository;
_aggregateChangesDetector = new DataChangesDetector <T, T>(_metadata.MapSpecificationProviderForSource, _metadata.MapSpecificationProviderForTarget, _query);
_valueObjectProcessors = _metadata.Elements.OfType <IValueObjectMetadataElement>().Select(valueObjectProcessorFactory.Create).ToArray();
}
public PeriodAggregateRootActor(
IQuery query,
IEqualityComparerFactory equalityComparerFactory,
IBulkRepository <Period> bulkRepository)
: base(query, equalityComparerFactory)
{
HasRootEntity(new PeriodAccessor(query), bulkRepository);
}
public ValueObjectActor(
IQuery query,
IBulkRepository <TDataObject> bulkRepository,
IEqualityComparerFactory equalityComparerFactory,
IStorageBasedDataObjectAccessor <TDataObject> storageBasedDataObjectAccessor)
: this(new EntityChangesProvider <TDataObject>(query, storageBasedDataObjectAccessor, equalityComparerFactory), bulkRepository, new NullDataChangesHandler <TDataObject>())
{
}
public EntityActor(
IQuery query,
IBulkRepository <TEntity> bulkRepository,
IEqualityComparerFactory equalityComparerFactory,
IStorageBasedDataObjectAccessor <TEntity> storageBasedDataObjectAccessor,
IDataChangesHandler <TEntity> dataChangesHandler,
IReadOnlyCollection <IActor> valueObjectActors)
: base(query, bulkRepository, equalityComparerFactory, storageBasedDataObjectAccessor, dataChangesHandler) =>
public CreateDataObjectsActor(
IdentityChangesProvider <TDataObject> changesProvider,
IBulkRepository <TDataObject> bulkRepository,
IDataChangesHandler <TDataObject> dataChangesHandler)
{
_changesProvider = changesProvider;
_bulkRepository = bulkRepository;
_dataChangesHandler = dataChangesHandler;
}
public DeleteInMemoryDataObjectsActor(
IdentityInMemoryChangesProvider <TDataObject> changesProvider,
IBulkRepository <TDataObject> bulkRepository,
IDataChangesHandler <TDataObject> dataChangesHandler)
{
_changesProvider = changesProvider;
_bulkRepository = bulkRepository;
_dataChangesHandler = dataChangesHandler;
}
public SyncEntityNameActor(IQuery query,
IBulkRepository <EntityName> bulkRepository,
IEqualityComparerFactory equalityComparerFactory)
{
_query = query;
_bulkRepository = bulkRepository;
_identityComparer = equalityComparerFactory.CreateIdentityComparer <EntityName>();
_completeComparer = equalityComparerFactory.CreateCompleteComparer <EntityName>();
}
public FactProcessor(FactMetadata <TFact> factMetadata, IFactDependencyProcessorFactory dependencyProcessorFactory, IQuery query, IBulkRepository <TFact> repository)
{
_query = query;
_repository = repository;
_factMetadata = factMetadata;
_depencencyProcessors = _factMetadata.Features.OfType <IFactDependencyFeature>().Select(dependencyProcessorFactory.Create).ToArray();
_indirectDepencencyProcessors = _factMetadata.Features.OfType <IIndirectFactDependencyFeature>().Select(dependencyProcessorFactory.Create).ToArray();
_changesDetector = new DataChangesDetector <TFact, TFact>(_factMetadata.MapSpecificationProviderForSource, _factMetadata.MapSpecificationProviderForTarget, _query);
}
public OrderAggregateRootActor(
IQuery query,
IEqualityComparerFactory equalityComparerFactory,
IBulkRepository <Order> bulkRepository,
IBulkRepository <Order.OrderTheme> orderThemeBulkRepository)
: base(query, equalityComparerFactory)
{
HasRootEntity(new OrderAccessor(query), bulkRepository,
HasValueObject(new OrderThemeAccessor(query), orderThemeBulkRepository));
}
public OrderAggregateRootActor(
IQuery query,
IEqualityComparerFactory equalityComparerFactory,
IBulkRepository <Order> orderBulkRepository,
IBulkRepository <Order.DebtPermission> debtPermissionBulkRepository)
: base(query, equalityComparerFactory)
{
HasRootEntity(new OrderAccessor(query), orderBulkRepository,
HasValueObject(new DebtPermissionAccessor(query), debtPermissionBulkRepository));
}
public FirmAggregateRootActor(
IQuery query,
IEqualityComparerFactory equalityComparerFactory,
IBulkRepository <Firm> bulkRepository,
IBulkRepository <Firm.CategoryPurchase> categoryPurchaseRepository)
: base(query, equalityComparerFactory)
{
HasRootEntity(new FirmAccessor(query), bulkRepository,
HasValueObject(new CategoryPurchaseAccessor(query), categoryPurchaseRepository));
}
public override Task OnActivateAsync()
{
_repository = new BulkUserRepository();
//Initializes on grain activation
users = new List <User>();
ReadState();
return(base.OnActivateAsync());
}
public RulesetAggregateRootActor(
IQuery query,
IEqualityComparerFactory equalityComparerFactory,
IBulkRepository <Ruleset> bulkRepository,
IBulkRepository <Ruleset.AdvertisementAmountRestriction> advertisementAmountRestrictionBulkRepository)
: base(query, equalityComparerFactory)
{
HasRootEntity(new RulesetAccessor(query), bulkRepository,
HasValueObject(new AdvertisementAmountRestrictionAccessor(query), advertisementAmountRestrictionBulkRepository));
}
public ThemeAggregateRootActor(
IQuery query,
IEqualityComparerFactory equalityComparerFactory,
IBulkRepository <Theme> bulkRepository,
IBulkRepository <Theme.InvalidCategory> invalidCategoryBulkRepository)
: base(query, equalityComparerFactory)
{
HasRootEntity(new ThemeAccessor(query), bulkRepository,
HasValueObject(new InvalidCategoryAccessor(query), invalidCategoryBulkRepository));
}
public SyncEntityNameActor(IQuery query,
ITenantProvider tenantProvider,
IBulkRepository <EntityName> bulkRepository,
IEqualityComparerFactory equalityComparerFactory)
{
_query = query;
_tenantProvider = tenantProvider;
_bulkRepository = bulkRepository;
_dataChangesDetector = new TwoPhaseDataChangesDetector <EntityName>(equalityComparerFactory);
}
public ProjectAggregateRootActor(
IQuery query,
IEqualityComparerFactory equalityComparerFactory,
IBulkRepository <Project> bulkRepository,
IBulkRepository <Project.ProjectDefaultTheme> projectDefaultThemeBulkRepository)
: base(query, equalityComparerFactory)
{
HasRootEntity(new ProjectAccessor(query), bulkRepository,
HasValueObject(new ProjectDefaultThemeAccessor(query), projectDefaultThemeBulkRepository));
}
public AccountAggregateRootActor(
IQuery query,
IEqualityComparerFactory equalityComparerFactory,
IBulkRepository <Account> accountBulkRepository,
IBulkRepository <Account.AccountPeriod> accountPeriodBulkRepository)
: base(query, equalityComparerFactory)
{
HasRootEntity(new AccountAccessor(query), accountBulkRepository,
HasValueObject(new AccountPeriodAccessor(query), accountPeriodBulkRepository));
}
protected EntityActorBase(IQuery query,
IBulkRepository <TDataObject> bulkRepository,
IEqualityComparerFactory equalityComparerFactory,
IStorageBasedDataObjectAccessor <TDataObject> storageBasedDataObjectAccessor,
IDataChangesHandler <TDataObject> dataChangesHandler)
: this(new CreateDataObjectsActor <TDataObject>(new IdentityChangesProvider <TDataObject>(query, storageBasedDataObjectAccessor, equalityComparerFactory), bulkRepository, dataChangesHandler),
new SyncDataObjectsActor <TDataObject>(new EntityChangesProvider <TDataObject>(query, storageBasedDataObjectAccessor, equalityComparerFactory), bulkRepository, dataChangesHandler),
new DeleteDataObjectsActor <TDataObject>(new IdentityChangesProvider <TDataObject>(query, storageBasedDataObjectAccessor, equalityComparerFactory), bulkRepository, dataChangesHandler))
{
}
public ReplaceDataObjectsActor(
IQuery query,
IBulkRepository <TDataObject> bulkRepository,
IMemoryBasedDataObjectAccessor <TDataObject> memoryBasedDataObjectAccessor,
IDataChangesHandler <TDataObject> dataChangesHandler)
{
_query = query;
_bulkRepository = bulkRepository;
_memoryBasedDataObjectAccessor = memoryBasedDataObjectAccessor;
_dataChangesHandler = dataChangesHandler;
}
public OrderAggregateRootActor(
IQuery query,
IEqualityComparerFactory equalityComparerFactory,
IBulkRepository <Order> bulkRepository,
IBulkRepository <Order.CategoryAdvertisement> categoryAdvertisementRepository,
IBulkRepository <Order.CostPerClickAdvertisement> costPerClickAdvertisementRepository)
: base(query, equalityComparerFactory)
{
HasRootEntity(new OrderAccessor(query), bulkRepository,
HasValueObject(new CategoryAdvertisementAccessor(query), categoryAdvertisementRepository),
HasValueObject(new CostPerClickAdvertisementAccessor(query), costPerClickAdvertisementRepository));
}
public FirmAggregateRootActor(
IQuery query,
IEqualityComparerFactory equalityComparerFactory,
IBulkRepository<Firm> firmRepository,
IBulkRepository<Firm.FirmPosition> firmPositionRepository,
IBulkRepository<Firm.FirmAssociatedPosition> firmAssociatedPositionRepository,
IBulkRepository<Firm.FirmDeniedPosition> firmDeniedPositionRepository)
: base(query, equalityComparerFactory)
{
HasRootEntity(new FirmAccessor(query), firmRepository,
HasValueObject(new FirmPositionAccessor(query), firmPositionRepository),
HasValueObject(new FirmAssociatedPositionAccessor(query), firmAssociatedPositionRepository),
HasValueObject(new FirmDeniedPositionAccessor(query), firmDeniedPositionRepository));
}
/// <summary>
/// Initializes a new instance of the <see cref="SimpleDataflowTaskFacts"/> class.
/// </summary>
public SimpleDataflowTaskFacts()
{
this.fixture = new Fixture();
this.source = this.fixture.CreateMany<FakeEntity>();
this.repository = Substitute.For<IBulkRepository<FakeEntity>>();
this.context = Substitute.For<ITaskContext>();
this.repository.BulkCopyAsync(
Arg.Do<IEnumerable<FakeEntity>>(a => this.data = a),
Arg.Any<ITaskContext>());
this.dataflow = new SimpleDataflowTask<FakeEntity, FakeEntity>(
this.source,
MappingFunctions.Identity,
this.repository);
}
public BulkWrapper(IBulkRepository bulkRepository, BulkWrapperConfiguration configuration)
{
if (bulkRepository == null)
{
throw new Exception("bulkRepository");
}
if (configuration == null)
{
throw new ArgumentNullException("configuration");
}
_config = configuration;
_bulkRepository = bulkRepository;
_bulkActionsQueue = new BlockingCollection<BulkActionBase>(_config.MaxActionQueueSize);
_bulkRequestsQueue = new BlockingCollection<BulkRequest>(_config.MaxRequestQueueSize);
_failures = new ConcurrentBag<BulkActionFailure>();
}