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);
}
