public OperationServices(IOperationRepository operationRepository,
IBaseRepository <SysOperation> baseRepository, IMapper mapper)
: base(baseRepository)
{
_operationRepository = operationRepository;
_mapper = mapper;
}
public OperationManager(IUnitOfWork unitOfWork, ILogger <OperationManager> logger, IBackgroundTaskDispatcher dispatcher, IServiceProvider serviceProvider)
{
_operationRepository = unitOfWork.OperationRepository;
_logger = logger;
_dispatcher = dispatcher;
_serviceProvider = serviceProvider;
}
public OperationService(IOperationRepository operationRepository, IDepartmentRepository departmentRepository, ICompanyRepository companyRepository, IFleetPoolRepository fleetPoolRepository)
{
this.operationRepository = operationRepository;
this.departmentRepository = departmentRepository;
this.companyRepository = companyRepository;
this.fleetPoolRepository = fleetPoolRepository;
}
private async Task SyncTransactionsAsync(
IEthplorerClient ethplorerClient,
IBloxyClient bloxyClient,
ITransactionRepository transactionService,
IOperationRepository operationService,
EthereumAddress contractAddress,
DateTime startDate,
DateTime endDate)
{
Console.WriteLine($"[{contractAddress}] Processing Batch: {startDate} -> {endDate}");
await foreach (var transactionSummary in bloxyClient.ListTransactionsAsync(contractAddress, startDate, endDate))
{
var hash = new EthereumTransactionHash(transactionSummary.Hash);
var transaction = await ethplorerClient.GetTransactionAsync(hash);
if (transaction != null)
{
Console.WriteLine($"[{contractAddress}] Discovering Hash {hash} with ({transaction.Operations.Count}) operations.");
var dynamoTransaction = MapTransaction(hash, contractAddress, transactionSummary, transaction);
await transactionService.UploadItemsAsync(dynamoTransaction);
var dynamoOperations = Enumerable.Range(0, transaction.Operations.Count)
.Select(i => MapOperation(hash, transaction.Operations[i], i))
.ToArray();
await operationService.UploadItemsAsync(dynamoOperations);
}
}
Console.WriteLine($"[{contractAddress}] Finished Batch: {startDate} -> {endDate}");
}
public AccountService(
IAccountRepository accountRepository,
IOperationRepository operationRepository)
{
_accountRepository = accountRepository;
_operationRepository = operationRepository;
}
/// <summary>
/// Constructor
/// </summary>
public VehicleService(IVehicleRepository vehicleRepository, IOperationRepository operationRepository, IFleetPoolRepository fleetPoolRepository,
ICompanyRepository companyRepository, IRegionRepository regionRepository, IFuelTypeRepository fuelTypeRepository,
IVehicleMakeRepository vehicleMakeRepository, IVehicleStatusRepository vehicleStatusRepository, IDepartmentRepository departmentRepository,
ITransmissionTypeRepository transmissionTypeResposirory, IBusinessPartnerRepository businessPartnerRepository,
IInsuranceTypeRepository insuranceTypeRepository, IMaintenanceTypeRepository maintenanceTypeRepository, IVehicleCheckListRepository vehicleCheckListRepository,
IVehicleModelRepository vehicleModelRepository, IVehicleCategoryRepository vehicleCategoryRepository, IOperationsWorkPlaceRepository operationsWorkPlaceRepository,
IVehicleMaintenanceTypeFrequencyRepository maintenanceTypeFrequencyRepository, IVehicleCheckListItemRepository vehicleCheckListItemRepository)
{
if (vehicleRepository == null)
{
throw new ArgumentNullException("vehicleRepository");
}
this.vehicleRepository = vehicleRepository;
this.operationRepository = operationRepository;
this.fleetPoolRepository = fleetPoolRepository;
this.companyRepository = companyRepository;
this.regionRepository = regionRepository;
this.fuelTypeRepository = fuelTypeRepository;
this.vehicleMakeRepository = vehicleMakeRepository;
this.vehicleStatusRepository = vehicleStatusRepository;
this.departmentRepository = departmentRepository;
this.transmissionTypeResposirory = transmissionTypeResposirory;
this.businessPartnerRepository = businessPartnerRepository;
this.insuranceTypeRepository = insuranceTypeRepository;
this.maintenanceTypeRepository = maintenanceTypeRepository;
this.vehicleCheckListRepository = vehicleCheckListRepository;
this.vehicleModelRepository = vehicleModelRepository;
this.vehicleCategoryRepository = vehicleCategoryRepository;
this.operationsWorkPlaceRepository = operationsWorkPlaceRepository;
this.maintenanceTypeFrequencyRepository = maintenanceTypeFrequencyRepository;
this.vehicleCheckListItemRepository = vehicleCheckListItemRepository;
}
public OperationService(ICategoryRepository categoryRepository, IOperationRepository operationRepository, IMapper mapper, IUnitOfWork unitOfWork)
{
_categoryRepository = categoryRepository;
_unitOfWork = unitOfWork;
_mapper = mapper;
_operationRepository = operationRepository;
}
public OperationTypeFamilyRepository(BudgetContext context,
IOperationRepository operationRepository,
IOperationTypeRepository operationTypeRepository) : base(context)
{
_operationRepository = operationRepository;
_operationTypeRepository = operationTypeRepository;
}
public SaleController(ISaleRepository saleRepository, ISellerRepository sellerRepository, IOperationRepository operationRepository, IReportRepository reportRepository)
{
_saleRepository = saleRepository;
_sellerRepository = sellerRepository;
_operationRepository = operationRepository;
_reportRepository = reportRepository;
}
public void SetUp()
{
IList <Operation> operations = new List <Operation>()
{
new Operation()
{
Operation1 = "Insert",
Table = "Customer",
Id = 1,
Description = "Customer Pedro was added.",
Date = new DateTime(2018, 06, 25, 12, 35, 50)
},
new Operation()
{
Operation1 = "Delete",
Table = "Product",
Description = "Product Pil was deleted.",
Date = new DateTime(2018, 06, 26, 09, 15, 10),
Id = 2
}
};
_mockOperationRepository = new Mock <IOperationRepository>();
_mockOperationRepository.Setup(mr => mr.GetAll()).Returns(operations);
_mockOperationRepository.Setup(mr => mr.Count()).Returns(operations.Count);
_mockOperationRepository.Setup(mr => mr.Get(It.IsAny <Expression <Func <Operation, bool> > >())).Throws(new NotSupportedException("Operation not supported."));
_mockOperationRepository.Setup(mr => mr.Delete(It.IsAny <Operation>())).Throws(new NotSupportedException("Operation not supported."));
_mockOperationRepository.Setup(mr => mr.Create(It.IsAny <Operation>())).Throws(new NotSupportedException("Operation not supported."));
_mockOperationRepository.Setup(mr => mr.Update(It.IsAny <Operation>())).Throws(new NotSupportedException("Operation not supported."));
_mockOperationRepository.Setup(mr => mr.ExecuteQuery(It.IsAny <string>())).Returns(new DataTable());
this.MockOperationRepository = _mockOperationRepository.Object;
}
public CreateQuizRejectedEventHandler(
IOperationRepository operationRepository,
IBusPublisher busPublisher)
{
_operationRepository = operationRepository.ThrowIfNull(nameof(operationRepository));
_busPublisher = busPublisher.ThrowIfNull(nameof(busPublisher));
}
public GetSelectListItemResponse GetOperationNumberList(string search)
{
GetSelectListItemResponse response = new GetSelectListItemResponse();
response.ListResponse = new List <SelectListItem>();
IOperationRepository operationRepository = IOCManagerFactory.Current.Resolve <IOperationRepository>();
var ListOperations = new List <MW.Domain.Entities.Operation>();
if (!string.IsNullOrEmpty(search))
{
ListOperations = operationRepository.GetByCriteria(o => o.OperationNumber.Contains(search)).ToList();
}
if (ListOperations != null && ListOperations.Any())
{
if (ListOperations.Any())
{
response.IsValid = true;
response.ListResponse = ListOperations.Select(o => new SelectListItem
{
Selected = false,
Value = o.OperationId.ToString(),
Text = o.OperationNumber,
}).ToList();
}
}
return(response);
}
public OperationPresenter(IView view, IOperationRepository repository)
{
_view = view;
view.OperationPresenter = this;
_repository = repository;
//UpdateQueryView();
}
public WashBll(IWashRepository washRepository, IOperationRepository operationRepository,
IContractRepository contractRepository)
{
_washRepository = washRepository;
_operationRepository = operationRepository;
_contractRepository = contractRepository;
}
/// <summary>
/// Constructor
/// </summary>
/// <param name="empRepository"></param>
/// <param name="empStatusRepository"></param>
/// <param name="companyRepository"></param>
/// <param name="jobTypeRepository"></param>
/// <param name="designationRepository"></param>
/// <param name="desigGradeRepository"></param>
/// <param name="departmentRepository"></param>
/// <param name="workplaceRepository"></param>
/// <param name="countryRepository"></param>
/// <param name="regionRepository"></param>
/// <param name="subRegionRepository"></param>
/// <param name="cityRepository"></param>
/// <param name="areaRepository"></param>
/// <param name="phoneTypeRepository"></param>
/// <param name="licenseTypeRepository"></param>
/// <param name="operationRepository"></param>
/// <param name="operationsWorkPlaceRepository"></param>
public EmployeeService(IEmployeeRepository empRepository, IEmpStatusRepository empStatusRepository, ICompanyRepository companyRepository,
IJobTypeRepository jobTypeRepository, IDesignationRepository designationRepository, IDesignGradeRepository desigGradeRepository,
IDepartmentRepository departmentRepository, IWorkplaceRepository workplaceRepository, ICountryRepository countryRepository,
IRegionRepository regionRepository, ISubRegionRepository subRegionRepository, ICityRepository cityRepository,
IAreaRepository areaRepository, IPhoneTypeRepository phoneTypeRepository, ILicenseTypeRepository licenseTypeRepository,
IOperationRepository operationRepository, IOperationsWorkPlaceRepository operationsWorkPlaceRepository, IAddressTypeRepository addressTypeRepository,
IAddressRepository addressRepository, IPhoneRepository phoneRepository, IEmpJobProgRepository empJobProgRepository,
IEmpAuthOperationsWorkplaceRepository empAuthOperationsWorkplaceRepository)
{
employeeRepository = empRepository;
this.empStatusRepository = empStatusRepository;
this.addressRepository = addressRepository;
this.phoneRepository = phoneRepository;
this.empJobProgRepository = empJobProgRepository;
this.empAuthOperationsWorkplaceRepository = empAuthOperationsWorkplaceRepository;
this.companyRepository = companyRepository;
this.jobTypeRepository = jobTypeRepository;
this.designationRepository = designationRepository;
this.desigGradeRepository = desigGradeRepository;
this.departmentRepository = departmentRepository;
this.workplaceRepository = workplaceRepository;
this.regionRepository = regionRepository;
this.countryRepository = countryRepository;
this.subRegionRepository = subRegionRepository;
this.cityRepository = cityRepository;
this.areaRepository = areaRepository;
this.phoneTypeRepository = phoneTypeRepository;
this.licenseTypeRepository = licenseTypeRepository;
this.operationRepository = operationRepository;
this.operationsWorkPlaceRepository = operationsWorkPlaceRepository;
this.addressTypeRepository = addressTypeRepository;
}
public void makeTransfer_NotEnoughMoneyDebitAccountButOverdraftAllowed()
{
//arrange
IOperationRepository operationRepository = MockRepository.GenerateStub <IOperationRepository>();
IRepository repository = MockRepository.GenerateMock <IRepository>();
IDtoCreator <Operation, OperationDto> operationCreator = MockRepository.GenerateStub <IDtoCreator <Operation, OperationDto> >();
Account debitAccount = new Account()
{
Id = 1, Balance = 0, AuthorizeOverdraft = true
};
Account creditAccount = new Account()
{
Id = 2, Balance = 300
};
repository.Expect(x => x.Get <Account>(debitAccount.Id)).Return(debitAccount);
repository.Expect(x => x.Get <Account>(creditAccount.Id)).Return(creditAccount);
//act
OperationServices services = new OperationServices(operationRepository, repository, operationCreator);
services.MakeTransfer(debitAccount.Id, creditAccount.Id, 200, "");
//assert
Assert.AreEqual(-200, debitAccount.Balance);
repository.VerifyAllExpectations();
}
public void GetOperations_AccountIdIsOk()
{
//arrange
IOperationRepository operationRepository = MockRepository.GenerateMock <IOperationRepository>();
IRepository repository = MockRepository.GenerateStub <IRepository>();
IDtoCreator <Operation, OperationDto> operationCreator = new OperationDtoCreator();
List <Operation> operations = new List <Operation>();
var id = 2;
operations.Add(new Operation {
Id = 3
});
operationRepository.Expect(x => x.GetOperationsByAccount(id)).Return(operations);
//act
OperationServices services = new OperationServices(operationRepository, repository, operationCreator);
IList <OperationDto> retrievedOperations = services.GetOperations(id);
//assert
Assert.AreEqual(1, retrievedOperations.Count);
Assert.AreEqual(3, retrievedOperations[0].Id);
operationRepository.VerifyAllExpectations();
}
public OperationService(
IEnumerable <IBuildTransactionStrategy> buildTransactionStrategies,
IBlockchain ethereumApi,
ILogFactory logFactory,
IOperationRepository operationRepository,
ITransactionService transactionService,
IQuorumTransactionSignerClient transactionSigner,
int?maxThreadCount = null)
{
_buildTransactionStrategies =
buildTransactionStrategies.ToDictionary(x => x.SupportedOperationType, x => x);
_ethereumApi = ethereumApi;
_log = logFactory.CreateLog(this);
_operationRepository = operationRepository;
_transactionService = transactionService;
_transactionSigner = transactionSigner;
_maxThreadCount = maxThreadCount ?? DefaultMaxThreadCount;
_sendTransactionRetryPolicy = Policy
.Handle <RpcClientTimeoutException>()
.WaitAndRetryAsync(
DefaultRetryCount,
attempt => TimeSpan.FromSeconds(Math.Pow(2, attempt)),
(ex, _) => _log.Error("Sending transaction with retry", ex));
}
public QuizCreatedEventHandler(
IBusPublisher busPublisher,
IOperationRepository operationRepository)
{
_busPublisher = busPublisher.ThrowIfNull(nameof(busPublisher));
_operationRepository = operationRepository.ThrowIfNull(nameof(operationRepository));
}
public AccountsService(IAccountRepository accountRepository, IOperationRepository operationRepository, IMapper mapper, IUserRepository userRepository)
{
_accountRepository = accountRepository;
_operationRepository = operationRepository;
_mapper = mapper;
_userRepository = userRepository;
}
public void SetUp()
{
_mocks = new MockRepository();
_repository = _mocks.Stub<IRepository>();
_operationRepository = _mocks.Stub<IOperationRepository>();
_accountRepository = _mocks.Stub<IAccountRepository>();
_helper = _mocks.Stub<IHelper>();
}
public OperationProvider(IProviderClient provider,
IOperationRepository operationRepository,
IOperationServiceClient serviceClient)
{
_provider = provider;
_operationRepository = operationRepository;
_serviceClient = serviceClient;
}
public OperationProvider(IOperationRepository operationRepository,
IProviderClient providerClient,
ProviderSettings providerSettings)
{
_operationRepository = operationRepository;
_providerClient = providerClient;
_providerSettings = providerSettings;
}
public TransactionController(ILeadRepository repo, IOperationRepository operation, IOptions <UrlOptions> options, IMapper mapper)
{
_repo = repo;
_restClient = new RestClient(options.Value.TransactionStoreAPIUrl);
_authentication = new GoogleAuthentication();
_mapper = mapper;
_operation = operation;
}
public TagService(IMapper mapper,
ICategoryRepository categoryRepository,
IOperationRepository operationRepository)
{
_mapper = mapper;
_categotyRepository = categoryRepository;
_operationRepository = operationRepository;
}
public OperationService(IOperationRepository operationRepository, ICardRepository cardRepository, IAccountRepository accountRepository, IUnitOfWork unitOfWork)
{
this.operationRepository = operationRepository;
this.cardRepository = cardRepository;
this.accountRepository = accountRepository;
this.unitOfWork = unitOfWork;
}
public DoctorService(IOperationRepository operationRepository, IAppointmentRepository appointmentRepository, IEmployeesScheduleRepository employeesScheduleRepository, IDoctorRepository doctorRepository)
{
this._doctorRepository = doctorRepository;
this._operationRepository = operationRepository;
this._appointmentRepository = appointmentRepository;
this._employeesScheduleRepository = employeesScheduleRepository;
this.regularAppointmentService = new RegularAppointmentService(appointmentRepository, employeesScheduleRepository, this, new PatientsRepository(), new OperationService(operationRepository));
}
public ChangeMatrixController(IResultsMatrixChangesModelRepository clientResultsMatrixChanges,
IOperationRepository operationRepository,
IDEMLockModulesService demLockModulesService)
{
_clientResultsMatrixChanges = clientResultsMatrixChanges;
_operationRepository = operationRepository;
_demLockModulesService = demLockModulesService;
}
public DoctorService(MyDbContext context)
{
this._doctorRepository = new DoctorRepository(context);
this._operationRepository = new OperationRepository(context);
this._appointmentRepository = new AppointmentRepository(context);
this._employeesScheduleRepository = new EmployeesScheduleRepository(context);
this.regularAppointmentService = new RegularAppointmentService(_appointmentRepository, _employeesScheduleRepository, this, new PatientsRepository(context), new OperationService(_operationRepository));
}
public RoleService(IControlRoomUnitOfWork unitOfWork)
{
this.unitOfWork = unitOfWork;
roleRepository = unitOfWork.RoleRepository;
operationCategoryRepository = unitOfWork.OperationCategoryRepository;
operationRepository = unitOfWork.OperationRepository;
menuRepository = unitOfWork.MenuRepository;
}
/// <summary>
/// Invoke a method marked with the SetupAttribute in the given instance of an object.
/// </summary>
/// <param name="instance">An object that should contain a method marked with a SetupAttribute.</param>
/// <param name="repos">The IOperationRepository that is currently being used.</param>
public void Invoke(object instance, IOperationRepository repos)
{
var method = GetSetupMethod(instance.GetType());
// It's ok not to have a setup method
if (null != method)
{
method.Invoke(instance, new[] { repos });
}
}
//private readonly IOperationTemplateProvider _templateProvider;
public OperationService(IOperationRepository operationRepository,
IMapper mapper //,
//IOperationTemplateProvider templateProvider
)
{
_operationRepository = operationRepository;
_mapper = mapper;
// _templateProvider = templateProvider;
}
public ServiceRtService(IOperationRepository operationRepository, ITariffTypeRepository tariffTypeRepository,
IServiceRtMainRepository serviceRtMainRepository, IServiceItemRepository serviceItemRepository, IServiceRtRepository serviceRtRepository)
{
this.operationRepository = operationRepository;
this.tariffTypeRepository = tariffTypeRepository;
this.serviceRtMainRepository = serviceRtMainRepository;
this.serviceItemRepository = serviceItemRepository;
this.serviceRtRepository = serviceRtRepository;
}
/// <summary>
/// Construct an instance of a type marked with the SetupAttribute and invoke its Setup method.
/// </summary>
/// <param name="type">The type marked with a SetupAttribute that should be instantiated and invoked.</param>
/// <param name="repos">The IOperationRepository that is currently being used.</param>
public void Invoke(Type type, IOperationRepository repos)
{
ConstructorInfo ci = type.GetConstructor(Type.EmptyTypes);
if (null == ci)
{
throw new MigrationContractException("Setup class must have a no argument constructor.", type);
}
var instance = ci.Invoke(null);
Invoke(instance, repos);
}
public ServiceOperationProvider(IOperationRepository operationRepository, IOperationProvider operationProvider)
{
if (operationRepository == null)
{
throw new ArgumentNullException("operationRepository");
}
if (operationProvider == null)
{
throw new ArgumentNullException("operationProvider");
}
_operationProvider = operationProvider;
_operationRepository = operationRepository;
}
public ArpagonUow()
{
// Context
CreateDbContext();
// Repos
_CategorieRepo = new CategorieBudgetRepository(db);
_BudgetRepo = new BudgetRepository(db);
_CompteBanqueRepo = new CompteBanqueRepository(db);
_BanqueRepo = new EFRepository<Banque>(db);
_CompteCaisseRepo = new CompteCaisseRepository(db);
_GroupeRepo = new GroupeRepository(db);
_ModeleMouvementBudgetRepo = new ModeleMouvementBudgetRepository(db);
_ModeleProvisionRepo = new ModeleProvisionRepository(db);
_ModeleRepo = new ModeleRepository(db);
_MouvementRepo = new MouvementBudgetRepository(db);
_MoyenPaiementRepo = new MoyenPaiementRepository(db);
_NoteRepo = new EFRepository<Note>(db);
_OperationRepo = new OperationRepository(db);
_FinancementRepo = new FinancementRepository(db);
_FinancementBudgetRepo = new FinancementBudgetRepository(db);
_ProvisionRepo = new ProvisionRepository(db);
_TypeOperationRepo = new EFRepository<TypeOperation>(db);
//_UserRepo = new UserRepository(db);
_UtilisateurRepo = new UtilisateurRepository(db);
_Chargement = new EFRepository<Chargement>(db);
_OperationRawSG = new RawRepository<OperationRawSG>(db);
_Contrat = new ContratRepository(db);
_EcheanceContrat = new EcheanceContratRepository(db);
_RapproEcheance = new RapproEcheanceRepository(db);
_RapproRaw = new RapproRawRepository(db);
_TraceLog = new TraceLogRepository(db);
}
public AddTable(IDriver driver, IOperationRepository oprepos)
{
this.driver = driver;
oprepository = oprepos;
addTableOp = oprepository.NewInstance<IAddTableOperation>();
}
public OperationService(OperationServiceDependencies dependencies)
{
dependencies.EnsureIsResolved();
_provider = dependencies.Provider;
_repository = dependencies.Repository;
}
public OperationBll(IOperationRepository operationRepository)
{
_operationRepository = operationRepository;
}
public void SetupFk(IOperationRepository repos)
{
Console.Out.WriteLine("XXX: In Setup");
repos.Register<IAddReferenceAndFkOperation>(typeof (AddRefAndFKOp));
}
public OperationsController(IOperationRepository repository)
{
_repository = repository;
}
public AccountRepository(ISessionFactory sessionFactory, IOperationRepository operationRepository)
{
_sessionFactory = sessionFactory;
_operationRepository = operationRepository;
}
public void Setup()
{
mocks = new MockRepository();
opRepos = mocks.StrictMock<IOperationRepository>();
driver = mocks.StrictMock<IDriver>();
schemaInfo = mocks.StrictMock<ISchemaInfo>();
}
public void Setup(IOperationRepository repository)
{
repository.Register<IGenericOperation>(typeof(String));
}
/// <summary>
/// Init controller for purse(money statistic)
/// </summary>
/// <param name="operationRepository">Object for connection to table of operation in database</param>
/// <param name="userRepository">Object for connection to table of user information in database</param>
public PurseController(IOperationRepository operationRepository, IUserRepository userRepository)
{
_operationRepository = operationRepository;
_userRepository = userRepository;
}
public AccountService(IAccountRepository accountRepository, IOperationRepository operationRepository)
{
_accountRepository = accountRepository;
_operationRepository = operationRepository;
}
public OperationServices(IOperationRepository operationRepository, IRepository repository, IDtoCreator<Operation, OperationDto> operationDtoCreator)
{
_operationRepository = operationRepository;
_repository = repository;
_operationCreator = operationDtoCreator;
}
private CardManager CreateSut(ICardRepository cardRepository, IOperationRepository operationRepository)
{
var userStore = Mock.Of<IUserStore<Card, int>>();
var unitOfWork = Mock.Of<IUnitOfWork>();
return new CardManager(userStore, cardRepository, operationRepository, unitOfWork);
}
public virtual void Setup(SetupRunner setupRunner, ILogger logger, IOperationRepository driver)
{
setupRunner.Invoke(migration, driver);
}