public TenantTests()
{
var databaseContext = new DatabaseContext();
_tenantRepository = new AggregateRepository <Tenant>(databaseContext);
_userRepository = new AggregateRepository <User>(databaseContext);
}
public CronusAggregateRepository(IAggregateRepository repository, IPublisher <IEvent> eventPublisher, IPublisher <IPublicEvent> publicEventPublisher, CronusContext context)
{
this.aggregateRepository = repository;
this.eventPublisher = eventPublisher;
this.publicEventPublisher = publicEventPublisher;
this.context = context;
}
public UploadDocumentCommandHandler(ILogger <UploadDocumentCommandHandler> logger,
IAggregateRepository <SIOStoreDbContext> aggregateRepository,
IAggregateFactory aggregateFactory,
IFileClient fileClient)
{
if (logger == null)
{
throw new ArgumentNullException(nameof(logger));
}
if (aggregateRepository == null)
{
throw new ArgumentNullException(nameof(aggregateRepository));
}
if (aggregateFactory == null)
{
throw new ArgumentNullException(nameof(aggregateFactory));
}
if (fileClient == null)
{
throw new ArgumentNullException(nameof(fileClient));
}
_logger = logger;
_aggregateRepository = aggregateRepository;
_aggregateFactory = aggregateFactory;
_fileClient = fileClient;
}
/// <summary>
/// Initializes a new instance of the <see cref="GolfClubMembershipApplicationService"/> class.
/// </summary>
/// <param name="golfClubRepository">The golf club repository.</param>
/// <param name="playerRepository">The player repository.</param>
/// <param name="golfClubMembershipRepository">The golf club membership repository.</param>
public GolfClubMembershipApplicationService(IAggregateRepository <GolfClubAggregate> golfClubRepository, IAggregateRepository <PlayerAggregate> playerRepository,
IAggregateRepository <GolfClubMembershipAggregate> golfClubMembershipRepository)
{
this.GolfClubRepository = golfClubRepository;
this.PlayerRepository = playerRepository;
this.GolfClubMembershipRepository = golfClubMembershipRepository;
}
public GetEventStoreAggregateRepositoryTests()
{
_id = "aggregate-" + Guid.NewGuid().ToString("n");
var source = new TaskCompletionSource <bool>();
_eventStoreInitialized = source.Task;
var notListening = new IPEndPoint(IPAddress.None, 0);
_node = EmbeddedVNodeBuilder
.AsSingleNode()
.WithExternalTcpOn(notListening)
.WithInternalTcpOn(notListening)
.WithExternalHttpOn(notListening)
.WithInternalHttpOn(notListening)
.RunProjections(ProjectionsMode.All);
_node.NodeStatusChanged += (_, e) =>
{
if (e.NewVNodeState != VNodeState.Master)
{
return;
}
source.SetResult(true);
};
_connection = EmbeddedEventStoreConnection.Create(_node);
_sut = new GetEventStoreAggregateRepository(_connection, new DefaultGetEventStoreJsonSerializer());
_node.Start();
}
public FiberCableCommandHandler(IAggregateRepository aggregateRepository, IRouteNetworkState routeNetworkQueryService, IConduitNetworkQueryService conduitNetworkQueryService, IFiberNetworkQueryService fiberNetworkQueryService)
{
this.repo = aggregateRepository;
this.conduitNetworkQueryService = conduitNetworkQueryService;
this.routeNetworkQueryService = routeNetworkQueryService;
this.fiberNetworkQueryService = fiberNetworkQueryService;
}
public EditCommentCommandHandler(
IAggregateRepository aggregateRepository,
IResourceAuthorizationService resourceAuthorizationService)
{
_aggregateRepository = aggregateRepository;
_resourceAuthorizationService = resourceAuthorizationService;
}
public static async Task <IActionResult> Run(
[HttpTrigger(AuthorizationLevel.Function, "get", "post", Route = null)] HttpRequest req,
[Inject] IAggregateRepository repository,
[Inject] IOrderHistory orderHistory,
[Inject] ICustomerHistory customerHistory)
{
var dict = req.GetQueryParameterDictionary();
var validator = new PlaceOrderValidator();
var result = await validator.Validate(
GetValueOrDefault("OrderNumber", dict),
GetValueOrDefault("CustomerId", dict),
orderHistory,
customerHistory);
if (!result.HasPassed)
{
return(new BadRequestObjectResult(result.Errors));
}
var order = new Order();
order.Place(validator.CustomerId, validator.OrderNumber);
await repository.Save(order);
return(new OkObjectResult("Thanks for placing an order"));
}
public AddToDoValidator(IAggregateRepository <ToDoList.ToDoList> toDoListAggregateRepository)
{
RuleFor(toDo => toDo.ToDoListId)
.Custom((toDoListId, context) =>
{
var toDoListAggregate = toDoListAggregateRepository
.LoadAsync(toDoListId)
.GetAwaiter()
.GetResult();
var isValidToDoList = toDoListAggregate.GetCommittedEvents().Count > 0;
if (!isValidToDoList)
{
context.AddFailure($"The {nameof(ToDoList.ToDoList)} is not valid.");
}
});
RuleFor(toDo => toDo.Label)
.NotNull()
.NotEmpty()
.Length(3, 255);
RuleFor(toDo => toDo.Description)
.NotNull()
.NotEmpty()
.Length(3, 255);
}
public CloneNoteCommandHandler(
ICurrentUser currentUser,
IAggregateRepository aggregateRepository)
{
_currentUser = currentUser;
_aggregateRepository = aggregateRepository;
}
public MultiConduitCommandHandler(IAggregateRepository aggregateRepository, IRouteNetworkState routeNetworkQueryService, IConduitNetworkQueryService conduitNetworkQueryService, IConduitSpecificationRepository conduitSpecificationRepository)
{
this.repo = aggregateRepository;
this.conduitNetworkQueryService = conduitNetworkQueryService;
this.routeNetworkQueryService = routeNetworkQueryService;
this.conduitSpecificationRepository = conduitSpecificationRepository;
}
public ConduitClosureCommandHandler(IAggregateRepository aggregateRepository, IRouteNetworkState routeNetworkQueryService, IConduitNetworkQueryService conduitNetworkQueryService, IConduitClosureRepository conduitClosureRepository)
{
this.repo = aggregateRepository;
this.routeNetworkQueryService = routeNetworkQueryService;
this.conduitNetworkQueryService = conduitNetworkQueryService;
this.conduitClosureRepository = conduitClosureRepository;
}
public DeleteSpaceCommandHandler(
IAggregateRepository aggregateRepository,
IResourceAuthorizationService authorizationService)
{
_aggregateRepository = aggregateRepository;
_resourceAuthorizationService = authorizationService;
}
public CreateCreditCardHandler(IAggregateRepository <CreditCard> creditCardRepo,
IAggregateRepository <CreditCardSubscription> subscriptionRepo, ISystemClock clock) : base(creditCardRepo)
{
_creditCardRepo = creditCardRepo;
_subscriptionRepo = subscriptionRepo;
_clock = clock;
}
public LoginCommandHandler(UserManager <SIOUser> userManager,
SignInManager <SIOUser> signInManager,
IAggregateRepository <SIOStoreDbContext> aggregateRepository,
IAggregateFactory aggregateFactory,
ILogger <LoginCommandHandler> logger)
{
if (userManager == null)
{
throw new ArgumentNullException(nameof(userManager));
}
if (signInManager == null)
{
throw new ArgumentNullException(nameof(signInManager));
}
if (aggregateRepository == null)
{
throw new ArgumentNullException(nameof(aggregateRepository));
}
if (aggregateFactory == null)
{
throw new ArgumentNullException(nameof(aggregateFactory));
}
if (logger == null)
{
throw new ArgumentNullException(nameof(logger));
}
_userManager = userManager;
_signInManager = signInManager;
_aggregateRepository = aggregateRepository;
_aggregateFactory = aggregateFactory;
_logger = logger;
}
private static async Task WaitForEventOrTimeout(
DurableOrchestrationContext context,
IAggregateRepository repository,
ILogger log,
OrderPlaced @event)
{
using (var timeoutCs = new CancellationTokenSource())
{
var waitForCancel = context.WaitForExternalEvent(InternalEvents.OrderCancelled);
var waitForTimeout = context.CreateTimer(@event.CooldownPeriodExpires, timeoutCs.Token);
log.LogInformation("Waiting for either a cooldown to expire OR the customer to cancel");
Task winner = await Task.WhenAny(waitForCancel, waitForTimeout);
if (winner == waitForCancel)
{
await CancelOrder(repository, log, @event);
}
else if (winner == waitForTimeout)
{
await ProvisionOrder(repository, log, @event);
}
if (!waitForTimeout.IsCompleted)
{
// All pending timers must be complete or cancelled before the function exits
timeoutCs.Cancel();
}
}
}
private MockDependencyResolver()
{
ContextFactory = new ThreadedContextItemCollectionFactory();
CorrelationIdHelper = new CorrelationIdHelper((ThreadedContextItemCollectionFactory)ContextFactory);
ConfigurationManager = new ConfigurationManager();
Logger = new TraceLogger(new LoggerSettings(), CorrelationIdHelper);
EventStore = EventStoreCreator(this);
Bus = new InProcessBus <TAuthenticationToken>
(
(IAuthenticationTokenHelper <TAuthenticationToken>) new DefaultAuthenticationTokenHelper(ContextFactory),
CorrelationIdHelper,
this,
Logger,
ConfigurationManager,
new BusHelper(ConfigurationManager, ContextFactory)
);
AggregateRepository = new AggregateRepository <TAuthenticationToken>
(
new AggregateFactory(this, Logger),
EventStore,
Bus,
CorrelationIdHelper,
ConfigurationManager
);
}
public GetEventStoreAggregateRepositoryTests()
{
_id = "aggregate-" + Guid.NewGuid().ToString("n");
var source = new TaskCompletionSource<bool>();
_eventStoreInitialized = source.Task;
var notListening = new IPEndPoint(IPAddress.None, 0);
_node = EmbeddedVNodeBuilder
.AsSingleNode()
.WithExternalTcpOn(notListening)
.WithInternalTcpOn(notListening)
.WithExternalHttpOn(notListening)
.WithInternalHttpOn(notListening)
.RunProjections(ProjectionsMode.All);
_node.NodeStatusChanged += (_, e) =>
{
if (e.NewVNodeState != VNodeState.Master)
{
return;
}
source.SetResult(true);
};
_connection = EmbeddedEventStoreConnection.Create(_node);
_sut = new GetEventStoreAggregateRepository(_connection, new DefaultGetEventStoreJsonSerializer());
_node.Start();
}
/// <summary>
/// Конструктор.
/// </summary>
/// <param name="aggregateRepository"><see cref="IAggregateRepository"/>.</param>
/// <param name="logger">Логгер.</param>
public CreateDistributionHandler(
IAggregateRepository aggregateRepository,
ILogger <CreateDistributionHandler> logger
) : base(logger)
{
this.aggregateRepository = aggregateRepository;
}
public NaturalKeyDrivenAggregateRepository(
IAggregateRepository <TAggregate, TInternalId> internalRepository,
INaturalKeyToAggregateIdMap <TNaturalKey, TInternalId, TAggregate> naturalKeyToAggregateIdMap)
{
_internalRepository = internalRepository;
_naturalKeyToAggregateIdMap = naturalKeyToAggregateIdMap;
}
/// <summary>
/// Instantiates a new instance of <see cref="SnapshotRepository{TAuthenticationToken}"/>.
/// </summary>
public SnapshotRepository(ISnapshotStore snapshotStore, ISnapshotStrategy <TAuthenticationToken> snapshotStrategy, IAggregateRepository <TAuthenticationToken> repository, IEventStore <TAuthenticationToken> eventStore, IAggregateFactory aggregateFactory)
{
SnapshotStore = snapshotStore;
SnapshotStrategy = snapshotStrategy;
Repository = repository;
EventStore = eventStore;
AggregateFactory = aggregateFactory;
}
public async Task Handle(SendMail command, IAggregateRepository repository)
{
var mail = new Mail();
mail.RequestMail(command);
await repository.Create(mail.RaiseNewEvents());
await mail.SendMail(this.mailService);
await repository.Update(mail.RaiseNewEvents());
}
/// <summary>
/// Initializes a new instance of the <see cref="TournamentCommandHandler" /> class.
/// </summary>
/// <param name="golfClubRepository">The golf club repository.</param>
/// <param name="tournamentRepository">The tournament repository.</param>
/// <param name="tournamentApplicationService">The tournament application service.</param>
public TournamentCommandHandler(IAggregateRepository <GolfClubAggregate> golfClubRepository,
IAggregateRepository <TournamentAggregate> tournamentRepository,
ITournamentApplicationService tournamentApplicationService)
{
this.GolfClubRepository = golfClubRepository;
this.TournamentRepository = tournamentRepository;
this.TournamentApplicationService = tournamentApplicationService;
}
/// <summary>
/// Конструктор.
/// </summary>
/// <param name="aggregateRepository"><see cref="IAggregateRepository"/>.</param>
/// <param name="logger">Logging.</param>
public DeleteBuildHandler(
IAggregateRepository aggregateRepository,
ILogger <DeleteBuildHandler> logger) :
base(logger)
{
this.aggregateRepository = aggregateRepository;
this.logger = logger;
}
public AggregateSnapshotRespositoryDecorator(IAggregateRepository decorated, IAggregateFactory aggregateFactory, IEventStore eventStore, ISnapshotStore snapshotStore, ISnapshotStrategy snapshotStrategy)
{
_decoratedRepository = decorated ?? throw new ArgumentNullException(nameof(decorated));
_aggregateFactory = aggregateFactory ?? throw new ArgumentNullException(nameof(aggregateFactory));
_eventStore = eventStore ?? throw new ArgumentNullException(nameof(eventStore));
_snapshotStore = snapshotStore ?? throw new ArgumentNullException(nameof(snapshotStore));
_snapshotStrategy = snapshotStrategy ?? throw new ArgumentNullException(nameof(snapshotStrategy));
}
public ClientApplicationService(IAggregateRepository<Client> clientRepository, IClientProjections clientProjections, IUnitOfWork unitOfWork)
{
this.clientRepository = clientRepository;
this.clientProjections = clientProjections;
this.unitOfWork = unitOfWork;
SubsribeToEvents();
}
public RetrospectivesController(IAggregateRepository agRepository,
IReadModelFacade readModel,
ICommandSender cmdSender)
{
_aggRepo = agRepository;
_read = readModel;
_cmdSender = cmdSender;
}
/// <summary>
/// Initializes a new instance of the <see cref="GolfClubCommandHandler" /> class.
/// </summary>
/// <param name="golfClubRepository">The golf club repository.</param>
/// <param name="oAuth2SecurityService">The o auth2 security service.</param>
/// <param name="golfClubMembershipApplicationService">The golf club membership application service.</param>
public GolfClubCommandHandler(IAggregateRepository <GolfClubAggregate> golfClubRepository,
ISecurityService oAuth2SecurityService,
IGolfClubMembershipApplicationService golfClubMembershipApplicationService)
{
this.GolfClubRepository = golfClubRepository;
this.OAuth2SecurityService = oAuth2SecurityService;
this.GolfClubMembershipApplicationService = golfClubMembershipApplicationService;
}
public BasketCommandDispatcher(IAggregateRepository aggregateRepository) : base(aggregateRepository)
{
RegisterHandler(Create);
RegisterHandler(RemoveItem);
RegisterHandler(CheckOut);
RegisterHandler(AddItem);
RegisterHandler(Cancel);
}
/// <summary>
/// Конструктор.
/// </summary>
/// <param name="aggregateRepository"><see cref="IAggregateRepository"/>.</param>
/// <param name="logger">Logging.</param>
protected UpdateBuildBaseHandler(
IAggregateRepository aggregateRepository,
ILogger <CommandHandlerBase <T> > logger) :
base(logger)
{
AggregateRepository = aggregateRepository;
Logger = logger;
}
public ProductCommandHandler(IAggregateRepository <Product> repository)
{
if (repository == null)
{
throw new ArgumentNullException(nameof(repository));
}
_repository = repository;
}
public TournamentApplicationService(IAggregateRepository <TournamentAggregate> tournamentRepository,
IAggregateRepository <PlayerAggregate> playerRepository,
IAggregateRepository <GolfClubMembershipAggregate> clubMembershipRepository)
{
this.TournamentRepository = tournamentRepository;
this.PlayerRepository = playerRepository;
this.ClubMembershipRepository = clubMembershipRepository;
}
/// <summary>
/// Конструктор.
/// </summary>
/// <param name="aggregateRepository"><see cref="IAggregateRepository"/>.</param>
/// <param name="logger">Logging.</param>
/// <param name="lifeCycleStateMapper"><see cref="IBuildLifeCycleStateMapper"/>.</param>
public UpdateBuildHandler(
IAggregateRepository aggregateRepository,
ILogger <UpdateBuildHandler> logger,
IBuildLifeCycleStateMapper lifeCycleStateMapper) :
base(aggregateRepository, logger)
{
this.lifeCycleStateMapper = lifeCycleStateMapper;
}
public async Task Handle(RetryMail command, IAggregateRepository repository)
{
var mail = new Mail();
var load = await repository.Get();
mail.LoadFromHistory(load.List);
mail.RetryMail();
await repository.Update(mail.RaiseNewEvents(), load.LastEventNumber);
await mail.SendMail(this.mailService);
await repository.Update(mail.RaiseNewEvents());
}
public AccountApplicationService(IAggregateRepository<Account> accountRepository, IAccountProjections accountProjections,
IAccountNumberService accountNumberService, IUnitOfWork unitOfWork)
{
this.accountRepository = accountRepository;
this.accountProjections = accountProjections;
this.accountNumberService = accountNumberService;
this.unitOfWork = unitOfWork;
SubsribeToEvents();
}
private async Task SaveAndTest(IAggregateRepository<IHomogeneousRole<RoleIdentifier>, RoleIdentifier> repo, params IHomogeneousRole<RoleIdentifier>[] roles)
{
foreach (var role in roles)
await repo.Save(role);
foreach (var role in roles)
{
var reconstituted = await repo.Get(role.Id);
reconstituted.Should().NotBeNull();
reconstituted.Should().NotBeSameAs(role);
reconstituted.Id.Should().Be(role.Id);
reconstituted.Version.Should().Be(role.Version);
reconstituted.Name.Should().Be(role.Name);
reconstituted.Status.Should().Be(role.Status);
}
}
/// <summary>
/// Ctor: Accepts instances via constructor injection
/// </summary>
/// <param name="aggregateRepository">Instance of the AggregateRepository</param>
/// <param name="dataSourceRepository">Instance of the DataSourceRepository</param>
/// <param name="dataTypeRepository">Instance of the DataType Repository</param>
/// <param name="importServiceResolver">Instance of the ImportServiceResolver</param>
/// <param name="dataSourceResolver">Instance of the DataSourceResolver</param>
public DataService(IAggregateRepository aggregateRepository, IDataSourceRepository dataSourceRepository, IDataTypeRepository dataTypeRepository, IImportServiceResolver importServiceResolver , IDataSourceResolver dataSourceResolver)
{
if (aggregateRepository == null)
throw new ArgumentNullException("aggregateRepository", "No valid AggregateRepository supplied to DataService.");
if (dataSourceRepository == null)
throw new ArgumentNullException("dataSourceRepository", "No valid DataSourceRepository supplied to DataService.");
if (dataTypeRepository == null)
throw new ArgumentNullException("dataTypeRepository", "No valid DataTypeRepository supplied to DataService.");
if (importServiceResolver == null)
throw new ArgumentNullException("importServiceResolver", "No valid ImportServiceResolver supplied to DataService.");
if (dataSourceResolver == null)
throw new ArgumentNullException("dataSourceResolver", "No valid DataSourceResolver supplied to DataService.");
_aggregateRepository = aggregateRepository;
_dataSourceRepository = dataSourceRepository;
_dataTypeRepository = dataTypeRepository;
_importServiceResolver = importServiceResolver;
_dataSourceResolver = dataSourceResolver;
}
private readonly IAggregateRepository _repository; // Repository to Aggregate model
#endregion Fields
#region Constructors
protected AbstractImportService(IAggregateRepository repository,
IDataSourceRepository dataSourceRepository,
IDataSource dataSource,
IMatchingAlgorithm matchingAlgorithm,
IMapper<ImportAggregate, Aggregate> mapper)
{
if (repository == null)
throw new ArgumentNullException("repository", "Invalid repository specified for import Service");
if (dataSourceRepository == null)
throw new ArgumentNullException("dataSourceRepository", "Invalid Datasource repository specified for import Service");
if (dataSource == null)
throw new ArgumentNullException("dataSource","Invalid datasource supplied to import Service");
if (matchingAlgorithm == null)
throw new ArgumentNullException("matchingAlgorithm", "Invalid matching algorithm supplied to import Service");
if (mapper == null)
throw new ArgumentNullException("mapper", "No valid mapper supplied to import service");
_repository = repository;
_dataSourceRepository = dataSourceRepository;
_datasource = dataSource;
_algorithm = matchingAlgorithm;
_mapper = mapper;
//_mapper = new ImportAggregateToAggregateMapper();
}
public AddProductToCartHandler(IAggregateRepository repository)
{
_repository = repository;
}
public AccountApplicationService(IAggregateRepository<Account> accountRepository, IAccountNumberService accountNumberService, IUnitOfWork unitOfWork)
{
this.accountRepository = accountRepository;
this.accountNumberService = accountNumberService;
this.unitOfWork = unitOfWork;
}
public ClientApplicationService(IAggregateRepository<Client> clientRepository, IUnitOfWork unitOfWork)
{
this.clientRepository = clientRepository;
this.unitOfWork = unitOfWork;
}
public RemoveProductFromCartHandler(IAggregateRepository repository)
{
_repository = repository;
}
public CommandExecutor(IAggregateRepository aggregateRepository)
{
this.repository = aggregateRepository;
this.versions = new Dictionary<Guid, int>();
}
private static Task Handle(object command, IAggregateRepository repository)
{
throw new Exception(string.Format("unknown {0} command", command.GetType()));
}
/// <summary>
/// Ctor: references the RenUkDataSource, otherwise all other dependencies are common
/// </summary>
/// <param name="repository">Common repository for the Aggregate</param>
/// <param name="dataSourceRepository">Common repository for the DataSource</param>
/// <param name="dataSource">RenUk Specific DataSource instance</param>
/// <param name="matchingAlgorithm">Common Matching algorithm</param>
/// <param name="mapper">Mapper class to map importaggregate to aggreate class</param>
public RenUkImportService(IAggregateRepository repository, IDataSourceRepository dataSourceRepository,
IRenUkDataSource dataSource, IMatchingAlgorithm matchingAlgorithm, IMapper<ImportAggregate, Aggregate> mapper)
: base(repository, dataSourceRepository, dataSource, matchingAlgorithm, mapper)
{
}
public void Initialise()
{
// Data Context and Repositories
_db = new AggregateContext();
_repository = new AggregateRepository(_db);
_dataSourceRepository = new DataSourceRepository(_db);
_dataTypeRepository = new DataTypeRepository(_db); // No parm, currently Enumeration
// DataSources and Resolver
var renUkHelper = new RenUkHtmlHelper();
_renUkDatasource = new RenUkDataSource(renUkHelper);
var snhHelper = new SnhKmlHelper();
_snhDataSource = new SnhDataSource(snhHelper);
_dataSourceResolver = new DataSourceResolver(_snhDataSource, _renUkDatasource);
// Matching algorithm
_coefficientAlgorithm = new DiceCoefficient();
_similarityAlgorithm = new LcSubstr();
_editDistanceAlgorithm = new LevenshteinEditDistance();
_preProcess = new PreProcessor();
_algorithm = new MatchingAlgorithm(_coefficientAlgorithm, 0.9f, _similarityAlgorithm, 0.9f,
_editDistanceAlgorithm, 2, _preProcess);
// Mapper class
_mapper = new ImportAggregateToAggregateMapper();
// Import Services and Resolver
_renUkImportService = new RenUkImportService(_repository, _dataSourceRepository, _renUkDatasource, _algorithm, _mapper);
_snhImportService = new SnhImportService(_repository, _dataSourceRepository, _snhDataSource, _algorithm,
_mapper);
_importServiceResolver = new ImportServiceResolver(_snhImportService, _renUkImportService);
}
public NEventStoreAggregateRepositoryTests()
{
_sut = new NEventStoreAggregateRepository(Wireup.Init().UsingInMemoryPersistence().Build());
}
public AuctionCommandHandler(IAggregateRepository<Auction> repository)
{
this.repository = repository;
}
public CustomerServices(IAggregateRepository repo)
{
_repo = repo;
}
public void Initialise()
{
_db = new AggregateContext();
_repository = new AggregateRepository(_db);
_dataSourceRepository = new DataSourceRepository(_db);
var helper = new SnhKmlHelper();
_datasource = new SnhDataSource(helper);
_coefficientAlgorithm = new DiceCoefficient();
_similarityAlgorithm = new LcSubstr();
_editDistanceAlgorithm = new LevenshteinEditDistance();
_preProcess = new PreProcessor();
_algorithm = new MatchingAlgorithm(_coefficientAlgorithm, 0.9f, _similarityAlgorithm, 0.9f,
_editDistanceAlgorithm, 2, _preProcess);
_mapper = new ImportAggregateToAggregateMapper();
_service = new SnhImportService(_repository, _dataSourceRepository, _datasource, _algorithm, _mapper);
}
public SaleCommandHandler(IAggregateRepository<Sale> repository)
{
this.repository = repository;
}
public WidgetCommandHandler(IAggregateRepository aggregateRepository)
{
_aggregateRepository = aggregateRepository;
}
