public ReportService(IRecordRepository repository, IReportConverter converter, IRecordValidator recordValidator, ITagRepository tagRepository) { _recordsRepository = repository; _converter = converter; _recordValidator = recordValidator; _tagRepository = tagRepository; }
public ApiController(ICountryRepository countryRepository, IArtistRepository artistRepository, IRecordRepository recordRepository, IGenreRepository genreRepository) { this.countryRepository = countryRepository; this.artistRepository = artistRepository; this.recordRepository = recordRepository; this.genreRepository = genreRepository; }
public UnitOfWork(SimpleMusicStoreDbContext db, IAddressRepository addresses, IArtistFollowRepository artistFollows, IArtistRepository artists, ILabelFollowRepository labelFollows, ILabelRepository labels, IOrderRepository orders, IRecordRepository records, IWishRepository wishes, IUserRepository users, ICommentRepository comments, IStockRepository stocks) { _db = db; Addresses = addresses; ArtistFollows = artistFollows; Artists = artists; LabelFollows = labelFollows; Labels = labels; Orders = orders; Records = records; Wishes = wishes; Users = users; Comments = comments; Stocks = stocks; }
public MainFormController(IWindowFormFactory winForFac, IUserRepository usrRepo, IRecordRepository rcdRepo, ICurrentUserRepository currUsrRepo) { windowFormsFactory = winForFac; userRepository = usrRepo; recordRepository = rcdRepo; currentUserRepository = currUsrRepo; }
public MonitorManager(IChannelRepository channelRepository, IMonitorRepository monitorRepository, IRecordRepository recordRepository, IScenarioRepository scenarioRepository) { this.channelRepository = channelRepository; this.monitorRepository = monitorRepository; this.recordRepository = recordRepository; this.scenarioRepository = scenarioRepository; }
public Record NewTransaction(IRecordRepository recordRepository, string bankBookOrCashBook, ChequeInfo chequeInfo = null) { Record transaction = default(Record); switch (bankBookOrCashBook) { case "BankBook": if (chequeInfo == null) { throw new Exception("chequeInfo can not be null"); } transaction = new TransactionInCheque(recordRepository) { ChequeInfo = chequeInfo }; break; case "CashBook": transaction = new TransactionInCash(recordRepository); break; default: throw new Exception("bankBookOrCashBook can be only BankBook or CashBook"); } return(transaction); }
public RecordsReportViewModel() { try { _logger.Info("Inside Records viewer view model construtor"); if (!ViewModelBase.IsInDesignModeStatic) { Alpharepo = new AlphaRepository(); Betarepo = new BetaRepository(); Gammarepo = new GammaRepository(); RecRepo = new RecordRepository(); StatusRepo = new StatusRepository(); DeltaRepo = new DeltaRepository(); ThetaRepo = new ThetaRepository(); SaveRecord = new RelayCommand(OnSave, canSave); SearchRecord = new RelayCommand(onSearch, canSearch); ExportToPDF = new RelayCommand(onExportToPdf, canExport); DeleteRecord = new RelayCommand(onDelete, canDelete); PdfFilterZeus = true; PdfFilterStatus = true; } } catch (Exception e) { _logger.Error("Some error have occured in RecordsReportViewModel, stacktrace=" + e.StackTrace); _logger.Error("RecordsReportViewModel error message is " + e.Message + " inner error is " + e.InnerException.Message); } }
public RecordsController(IRecordRepository repo, IMapper mapper, IPatientRepository patientRepo) { _repo = repo; _mapper = mapper; _patientRepo = patientRepo; }
public RecordService(IRecordRepository recordRepository, LogAppContext logAppContext, IHubContext <NotifyHub, IMesageHubClient> hubContext) { _recordRepository = recordRepository; _context = logAppContext; _recordsValidator = new RecordValidator(); _hubContext = hubContext; }
public ProposalController(IRecordRepository <Proposal> repositoryProposal, IRecordRepository <Client> repositoryClient, IRecordRepository <Rider> repositoryRider ) { this.repositoryProposal = repositoryProposal; this.repositoryClient = repositoryClient; this.repositoryRider = repositoryRider; }
public RecordService(IUnitOfWork unitOfWork, IUserService userService, IRecordGuard guard, IRecordMapper mapper) : base(unitOfWork, userService) { _repository = unitOfWork.RecordRepository; _guard = guard; _mapper = mapper; }
public RecordService(IRecordRepository recordRepository, ISettingHourlyLabelService iSettingService, IMapper mapper, MapperConfiguration configMapper, IMesService iMesService) { _recordRepository = recordRepository; _iSettingService = iSettingService; _iMesService = iMesService; _mapper = mapper; _configMapper = configMapper; }
public DataBase(IReaderRepository readerRepo, IRecordRepository recordRepo, IBookRepository bookRepo, IAuthorRepository authorRepo, IBookAuthorRepository bookAuthorRepo) { this.readerRepo = readerRepo; this.recordRepo = recordRepo; this.bookRepo = bookRepo; this.authorRepo = authorRepo; this.bookAuthorRepo = bookAuthorRepo; }
public RecordService( IRecordRepository recordsRepository, IAccountRepository accountRepository, IDateTimeProvider dateTimeProvider) { _recordRepository = recordsRepository; _accountRepository = accountRepository; _dateTimeProvider = dateTimeProvider; }
public ShoppingCart(IClaimAccessor currentUser, IRecordRepository records, IMapper mapper, IServiceValidator validator) { _records = records; _currentUser = currentUser; _mapper = mapper; _validator = validator; }
public static async Task TestDelete <T, TId, TQuery>(this IRecordRepository <T, TId, TQuery> repository, TId id) where TId : class where T : RHasId <TId> where TQuery : QueryRequest, new() { var result = await repository.Delete(id); Assert.IsTrue(result); var item = await repository.Get(id); Assert.IsNull(item); }
public static async Task TestUpdate <T, TId, TQuery>(this IRecordRepository <T, TId, TQuery> repository, T value) where TId : class where T : RHasId <TId> where TQuery : QueryRequest, new() { var result = await repository.Update(value); Assert.IsTrue(result); var item = await repository.Get(value.Id); item.ShouldDeepEqual(value); }
public DataProvider(IOaiConfiguration configuration, IMetadataFormatRepository metadataFormatRepository, IRecordRepository recordRepository, ISetRepository setRepository, IDateConverter dateConverter, IResumptionTokenConverter resumptionTokenConverter) { _configuration = configuration; _dateConverter = dateConverter; _resumptionTokenConverter = resumptionTokenConverter; _metadataFormatRepository = metadataFormatRepository; _recordRepository = recordRepository; _setRepository = setRepository; }
public RepositoryManager(ICompanyRepository companyRepository, IRecordRepository recordRepository, IExpertRepository expertRepository, IPhotoRepository photoRepository) { _companyRepository = companyRepository; _recordRepository = recordRepository; _expertRepository = expertRepository; _photoRepository = photoRepository; }
public RecordController(IRecordRepository recordRepository, IFuelCardRepository fuelCardRepository, ICorporationRepository corporationRepository, ICostAllocationRepository costAllocationRepository, IMapper mapper) : base( recordRepository, mapper) { _recordRepository = recordRepository; _fuelCardRepository = fuelCardRepository; _corporationRepository = corporationRepository; _costAllocationRepository = costAllocationRepository; _mapper = mapper; }
public bool LoginUserController(IHomeView HomeView, IUserRepository usrRepo, IRecordRepository recRepo, ICurrentUserRepository currUsrRepo) { if (usrRepo.checkCredentials(username, password)) { currUsrRepo.setUsername(username); recRepo.AddUserToDictionary(username, new List <Record>()); HomeView.ShowViewModal(recRepo, currUsrRepo); // saljes usrRepo tako da nakon sta se drugi put logira da povuce podatke return(true); } return(false); }
public ShoppingCartCacheProxy( IClaimAccessor currentUser, IRecordRepository records, IMapper mapper, IDatabase cacheProvider, IServiceValidator validator) : base(currentUser, records, mapper, validator) { _cacheProvider = cacheProvider; _items = FindCurrentUserCart(); }
public bool ShowViewModal(IRecordRepository recordRepository, ICurrentUserRepository currentUserRepository) { List <Record> allRecords = recordRepository.getAllRecords(currentUserRepository.getUsername()); foreach (Record record in allRecords) { listView1.Items.Add(new ListViewItem(new string[] { record.Date, record.Feeling, record.Keywords })); } Show(); return(true); }
public void SaveEditChanges(string date, IRecordRepository recordRepository, ICurrentUserRepository currentUserRepository) { Record record = recordRepository.getRecordByID(currentUserRepository.getUsername(), date); record.Feeling = feeling; record.Description = description; record.Diet = diet; record.Keywords = keywords; ((IObservable)recordRepository).NotifyObservers(); }
public static async Task <TId> TestCreate <T, TId, TQuery>(this IRecordRepository <T, TId, TQuery> repository, T value) where TId : class where T : RHasId <TId> where TQuery : QueryRequest, new() { var result = await repository.Create(value); Assert.IsNotNull(result); var item = await repository.Get(result); item.WithDeepEqual(value).IgnoreSourceProperty(x => x.Id); return(result); }
public RecordsController(IRecordRepository repository, IUserRepository userRepository, IVideoRepository videoRepository, IMapper mapper, LinkGenerator linkGenerator) { this.repository = repository; this.userRepository = userRepository; this.videoRepository = videoRepository; this.mapper = mapper; this.linkGenerator = linkGenerator; }
public void CreateHelpers() { _callRegistration = ObjectFactory.GetInstance<ICallRegistration>(); _callSearch = ObjectFactory.GetInstance<ICallSearch>(); _accountingMachine = ObjectFactory.GetInstance<IAccountingMachine>(); _recordRepository = ObjectFactory.GetInstance<IRecordRepository>(); _discountRepository = ObjectFactory.GetInstance<IDiscountRepository>(); _customerRegistration = ObjectFactory.GetInstance<ICustomerRegistration>(); _subscriptionRegistration = ObjectFactory.GetInstance<ISubscriptionRegistration>(); _serviceChargeRegistration = ObjectFactory.GetInstance<IServiceChargeRegistration>(); _serviceChargeSearch = ObjectFactory.GetInstance<IServiceChargeSearch>(); }
public async Task SyncRecordRepository <T, TId, TQuery>(IRecordRepository <T, TId, TQuery> source, IRecordRepository <T, TId, TQuery> target, bool full) where TId : class where T : RHasId <TId> where TQuery : QueryRequest, new() { HashSet <TId> remoteIds = await target.All().ToHashSetAsync(); await foreach (var item in source.GetAllItems().IgnoreNull()) { Logger.LogInformation($"Loaded {item.Id}"); if (remoteIds.Contains(item.Id)) { var result = await target.Update(item); if (result) { Logger.LogInformation($"Updated {item.Id}"); } else { Logger.LogError($"Failed to update {item.Id}"); } } else { var result = await target.Create(item); if (result is null) { Logger.LogError($"Failed to create {item.Id}"); } else { Logger.LogInformation($"Created {item.Id}"); } } remoteIds.Remove(item.Id); } if (full) { foreach (var v in remoteIds) { var result = await target.Delete(v); if (result) { Logger.LogInformation($"Deleted {v}."); } else { Logger.LogError($"Failed to deleted {v}."); } } } }
public BoardController(IUserRepository users, IBoardRepository boards, IColumnRepository columns, IRecordRepository records, IImageRepository images, IWebHostEnvironment appEnvironment) { _users = users; _boards = boards; _columns = columns; _records = records; _images = images; _appEnvironment = appEnvironment; }
public UnitOfWork(LibraryContext libraryContext, IReaderRepository readerRepository, IReaderCardRepository readerCardRepository, IRecordRepository recordRepository, IBookRepository bookRepository, IChapterRepository chapterRepository, IAuthorBookRepository authorBookRepository, IAuthorRepository authorRepository) { _libraryContext = libraryContext; ReaderRepository = readerRepository; ReaderCardRepository = readerCardRepository; RecordRepository = recordRepository; BookRepository = bookRepository; ChapterRepository = chapterRepository; AuthorBookRepository = authorBookRepository; AuthorRepository = authorRepository; }
public UnitOfWork(LibraryContext libraryContext, SignInManager <User> signInManager, UserManager <User> userManager, IReaderRepository readerRepository, IReaderCardRepository readerCardRepository, IRecordRepository recordRepository, IBookRepository bookRepository, IChapterRepository chapterRepository, IAuthorBookRepository authorBookRepository, IAuthorRepository authorRepository) { _libraryContext = libraryContext; SignInManager = signInManager; UserManager = userManager; ReaderRepository = readerRepository; ReaderCardRepository = readerCardRepository; RecordRepository = recordRepository; BookRepository = bookRepository; ChapterRepository = chapterRepository; AuthorBookRepository = authorBookRepository; AuthorRepository = authorRepository; }
public static async Task <IEnumerable <TId> > TestAll <T, TId, TQuery>(this IRecordRepository <T, TId, TQuery> repository) where TId : class where T : RHasId <TId> where TQuery : QueryRequest, new() { var result = repository.All(); Assert.IsNotNull(result); List <TId> res = new List <TId>(); await foreach (var v in result) { res.Add(v); await repository.TestGet(v); } return(res); }
public Record NewTransaction(IRecordRepository recordRepository, string bankBookOrCashBook, ChequeInfo chequeInfo = null) { Record transaction = default(Record); switch (bankBookOrCashBook) { case "BankBook": if (chequeInfo == null) throw new Exception("chequeInfo can not be null"); transaction = new TransactionInCheque(recordRepository) { ChequeInfo = chequeInfo }; break; case "CashBook": transaction = new TransactionInCash(recordRepository); break; default: throw new Exception("bankBookOrCashBook can be only BankBook or CashBook"); } return transaction; }
public BillGenerator(ISubscriptionSearch subscriptionSearch, IRecordRepository recordRepository, IDiscountRepository discountRepository) { _subscriptionSearch = subscriptionSearch; _recordRepository = recordRepository; _discountRepository = discountRepository; }
public RecordGenerator(ICallSearch callSearch, IServiceChargeSearch serviceChargeSearch, IRecordRepository recordRepository) { _callSearch = callSearch; _serviceChargeSearch = serviceChargeSearch; _recordRepository = recordRepository; }
public void Setup() { _records = new List<Record>(); _sut = new InMemoryRecordRepository(_records); }
public RecordService(IRecordRepository repository) { this.RecordRepository = repository; this.AddDisposableObjects(repository); }
public void Setup() { _recordRepository = MockRepository.GenerateMock<IRecordRepository>(); _sortFactory = MockRepository.GenerateMock<ISortStrategyFactory>(); _sut = new RecordsController(_sortFactory,_recordRepository); }