public void Initialize()
{
this.validationManager = Substitute.For <IValidatorManager>();
this.applicationArgs = Substitute.For <IApplicationArguments>();
this.printer = Substitute.For <IPrinter>();
this.environment = Substitute.For <IEnvironment>();
}
public AllPaymentsActionProvider(
IValidationService validationService,
IValidatorManager <AllPaymentsValidator, CoreModel.PaymentsFilter> validator,
IPaymentRepository repository,
ILogger <AllPaymentsActionProvider> log)
{
_validationService = validationService;
_validator = validator;
_repository = repository;
_log = log;
}
public LastPaymentsActionProvider(
IValidationService validationService,
IValidatorManager <LastPaymentValidator, string> validator,
IPaymentRepository repository,
ILogger <LastPaymentsActionProvider> log)
{
_validationService = validationService;
_validator = validator;
_repository = repository;
_log = log;
}
public RegistrationAction(IUserRepository userRepository,
IUserService userService,
IValidationService validationService,
IValidatorManager <RegistrationValidator, payment_gateway_repository.Model.User> validator,
ILogger <RegistrationAction> log)
{
_userRepository = userRepository;
_userService = userService;
_validationService = validationService;
_validator = validator;
_log = log;
}
public ProcessPaymentAction(IPaymentRepository repository,
IValidationService validationService,
IBankProcessor bankProcessor,
IValidatorManager <PaymentValidator, payment_gateway_repository.Model.Payment> validator,
ILogger <ProcessPaymentAction> log)
{
_repository = repository;
_validationService = validationService;
_bankProcessor = bankProcessor;
_validator = validator;
_log = log;
}
public Task <object> ProcessValidation <TClass, TModel>(IValidatorManager <TClass, TModel> validator, TModel model)
where TClass : class
where TModel : class
{
foreach (var itemFunc in validator.GetValidatorsResult(model).Result)
{
var result = itemFunc.Invoke();
if (result.StatusCode != StatusCode.Success)
{
return(Task.FromResult <object>(result));
}
}
return(Task.FromResult(validator.ReturnObject));
}
private const int BatchSize = 1000; // TODO: calculate batch size
public BlockProducer(
ITransactionPool transactionPool,
IValidatorManager validatorManager,
IBlockSynchronizer blockSynchronizer,
IBlockManager blockManager,
IStateManager stateManager,
ITransactionBuilder transactionBuilder
)
{
_transactionPool = transactionPool;
_validatorManager = validatorManager;
_blockSynchronizer = blockSynchronizer;
_blockManager = blockManager;
_stateManager = stateManager;
_transactionBuilder = transactionBuilder;
}
public ArgumentWrapper(
IValidatorManager validationManager,
IApplicationArguments applicationArguments,
IPrinter printer,
IEnvironment environment)
{
this.printer = printer;
this.environment = environment;
try
{
validationManager.RunAllValidations();
this.StartDate = DateTime.Parse(applicationArguments.Args[0], CultureInfo.CurrentCulture);
this.EndDate = DateTime.Parse(applicationArguments.Args[1], CultureInfo.CurrentCulture);
}
catch (ArgumentException e)
{
this.printer.PrintError(e.Message);
this.environment.Exit(1);
}
}
