public MemberService(ICommonRepository <Member> memberRepository,
ICommonRepository <Shift> shiftRepository,
IActivitiesRelationshipRepository activitiesRelationshipRepository)
{
_memberRepository = memberRepository;
_shiftRepository = shiftRepository;
_activitiesRelationshipRepository = activitiesRelationshipRepository;
}
public RecipesController(ICommonRepository <User> d2, ICommonRepository <UserProduct> d3,
ICommonRepository <Recipe> d4, ICommonRepository <Ingredient> d5)
{
dataUsers = d2;
dataUserProducts = d3;
dataRecipes = d4;
dataIngredients = d5;
}
public TerapeutaController(IConfiguration configuration,
ICommonRepository commonRepository,
IPsicologoRepository psicologoRepository)
{
this._configuration = configuration;
this._commonRepository = commonRepository;
this._psicologoRepository = psicologoRepository;
}
public PullKeyValueEntryQueryHandler(IValidator validator, ICommonRepository commonRepository)
{
NullGuard.NotNull(validator, nameof(validator))
.NotNull(commonRepository, nameof(commonRepository));
_validator = validator;
_commonRepository = commonRepository;
}
public CommonService(ICommonRepository repo, IUserManager userManager, IDateTime dateTime,
ISecurityConfig securityConfig)
{
_repo = repo;
_userManager = userManager;
_dateTime = dateTime;
_securityConfig = securityConfig;
}
public MasterConfigServices(ILogger <MasterConfigServices> log, ILogger <BasePage> logger, ICommonRepository <CityMaster> commonRepoCity, ICommonRepository <StateMaster> commonRepoState, ICommonRepository <CountryMaster> commonRepoCountry, ICommonRepository <ZipCodeMaster> commonRepoZipCode) : base(logger)
{
_commonRepoCity = commonRepoCity;
_commonRepoState = commonRepoState;
_commonRepoCountry = commonRepoCountry;
_commonRepoZipCode = commonRepoZipCode;
_log = log;
}
public UsuarioRepository(BillycockServiceContext context, ICommonRepository <Usuario> commonRepository,
IPlataformaCuentaRepository plataformaCuentaRepository, IPlataformaRepository plataformaRepository)
{
_context = context;
_commonRepository = commonRepository;
_plataformaCuentaRepository = plataformaCuentaRepository;
_plataformaRepository = plataformaRepository;
}
public ProductService(ICommonRepository <Product> productRepository, ICommonRepository <Seller> sellerRepository
, ISellerService sellerService, ICommonRepository <Category> categoryRepository)
{
_productRepository = productRepository;
_sellerRepository = sellerRepository;
_sellerService = sellerService;
_categoryRepository = categoryRepository;
}
//Set private interface equal null.
private void ResetRepositories()
{
commonRepo = null;
app200Repo = null;
app300Repo = null;
app400Repo = null;
app500Repo = null;
}
protected KeyValueEntryIdentificationCommandHandlerBase(IValidator validator, ICommonRepository commonRepository)
{
NullGuard.NotNull(validator, nameof(validator))
.NotNull(commonRepository, nameof(commonRepository));
Validator = validator;
CommonRepository = commonRepository;
}
public static CommentService Instance(ICommonRepository <Comment> repository)
{
if (repository == null)
{
throw new Exception("Can not create CommentService");
}
_instance.Value._repository = repository;
return(_instance.Value);
}
public CommisionService(ICommonRepository commonRepository, IClientRepository clientRepository,
IPolicyRepository policyRepository, ICommisionRepository commissionRepository, ICarrierRepository carrierRepository)
{
_commonRepository = commonRepository;
_clientRepository = clientRepository;
_policyRepository = policyRepository;
_commissionRepository = commissionRepository;
_carrierRepository = carrierRepository;
}
public AdminController(ICommonRepository commonRepo,
IExpenseRepository expenseRepo,
IIncomeRepository incomeRepo, IMapper mapper)
{
_commonRepo = commonRepo;
_expenseRepo = expenseRepo;
_incomeRepo = incomeRepo;
_mapper = mapper;
}
public UploadCityCommandHandler(
ICommonRepository commonRepository,
UserManager <cor_useraccount> userManager,
IHttpContextAccessor httpContextAccessor)
{
_repo = commonRepository;
_accessor = httpContextAccessor;
_userManager = userManager;
}
public override IValidator Validate(IValidator validator, ICommonRepository commonRepository)
{
NullGuard.NotNull(validator, nameof(validator))
.NotNull(commonRepository, nameof(commonRepository));
return(base.Validate(validator, commonRepository)
.Object.ShouldBeKnownValue(Number, number => Task.Run(async() => await GetLetterHeadAsync(commonRepository) != null), GetType(), nameof(Number))
.Object.ShouldBeDeletable(Number, number => GetLetterHeadAsync(commonRepository), GetType(), nameof(Number)));
}
public static CommentService Instance(ICommonRepository<Comment> repository)
{
if (repository == null)
{
throw new Exception("Can not create CommentService");
}
_instance.Value._repository = repository;
return _instance.Value;
}
public CommunicationService(ILogger <CommunicationService> log, ILogger <BasePage> logger, ICommonRepository <CommServiceTypeMaster> CommServiceTypeMaster, ICommonRepository <TemplateMaster> TemplateMaster, CleanArchitectureContext dbContext, Microsoft.Extensions.Configuration.IConfiguration configuration, IMasterConfigurationRepository masterConfigurationRepository, ICommonRepository <LimitRuleMaster> LimitRuleMaster) : base(logger)
{
_CommServiceTypeMaster = CommServiceTypeMaster;
_TemplateMaster = TemplateMaster;
_log = log;
_masterConfigurationRepository = masterConfigurationRepository;
_configuration = configuration;
_LimitRuleMaster = LimitRuleMaster;
}
public UploadWorkflowLevelCommandHandler(
IWorkflowRepository workflowRepository,
IHttpContextAccessor httpContextAccessor,
ICommonRepository commonRepository)
{
_repo = workflowRepository;
_commonRepo = commonRepository;
_accessor = httpContextAccessor;
}
public async Task PullKeyValueEntryAsync_WhenKeyHasNotBeenPushed_ReturnsNull()
{
ICommonRepository sut = CreateSut();
string key = BuildKey();
IKeyValueEntry result = await sut.PullKeyValueEntryAsync(key);
Assert.That(result, Is.Null);
}
public ConnectionHub(IDelivererService delivererService, ICommonRepository <Location> locationRepository,
ILocationService LocationService, IOrderService orderService, ISellerService sellerService)
{
_delivererService = delivererService;
_locationRepository = locationRepository;
_LocationService = LocationService;
_orderService = orderService;
_sellerService = sellerService;
}
public ProductsController(ICommonRepository<Product> d, ICommonRepository<UserProduct> d2,
ICommonRepository<User> d3,
ICommonRepository<Category> d4)
{
dataP = d;
dataUP = d2;
dataU = d3;
dataC = d4;
}
public ProductsController(ICommonRepository <Product> d, ICommonRepository <UserProduct> d2,
ICommonRepository <User> d3,
ICommonRepository <Category> d4)
{
dataP = d;
dataUP = d2;
dataU = d3;
dataC = d4;
}
public GetCompanyStructureDefinitionQueryHandler(
ICompanyRepository companyRepository,
DataContext dataContext,
IAdminRepository adminRepository,
ICommonRepository commonRepository)
{
_compRepo = companyRepository;
_dataContext = dataContext;
_adminRepository = adminRepository;
}
public void CreateLetterHeadAsync_WhenLetterHeadIsNull_ThrowsArgumentNullException()
{
ICommonRepository sut = CreateSut();
ArgumentNullException result = Assert.ThrowsAsync <ArgumentNullException>(async() => await sut.CreateLetterHeadAsync(null));
// ReSharper disable PossibleNullReferenceException
Assert.That(result.ParamName, Is.EqualTo("letterHead"));
// ReSharper restore PossibleNullReferenceException
}
protected AccountingIdentificationCommandHandlerBase(IValidator validator, IAccountingRepository accountingRepository, ICommonRepository commonRepository)
{
NullGuard.NotNull(validator, nameof(validator))
.NotNull(accountingRepository, nameof(accountingRepository))
.NotNull(commonRepository, nameof(commonRepository));
Validator = validator;
AccountingRepository = accountingRepository;
CommonRepository = commonRepository;
}
public void PullKeyValueEntryAsync_WhenKeyIsWhiteSpace_ThrowsArgumentNullException()
{
ICommonRepository sut = CreateSut();
ArgumentNullException result = Assert.ThrowsAsync <ArgumentNullException>(async() => await sut.PullKeyValueEntryAsync(" "));
// ReSharper disable PossibleNullReferenceException
Assert.That(result.ParamName, Is.EqualTo("key"));
// ReSharper restore PossibleNullReferenceException
}
public static T GetById <T>(this ICommonRepository <T> repository, int Id) where T : IWithId
{
var result = repository.GetAll().FirstOrDefault(x => x.Id == Id);
if (result == null)
{
throw new ServiceException(ServiceExceptionType.EntityNotFound);
}
return(result);
}
public void FindStudents_ValidCall()
{
MockCommonRepository.Setup(mr => mr.FindAllStudentGrades()).Returns(GetSampleStudents());
_mockCommonRepository = MockCommonRepository.Object;
IEnumerable <CommonModel> expected = _mockCommonRepository.FindAllStudentGrades();
Assert.True(expected != null); // Test if null
Assert.AreEqual(GetSampleStudents().Count(), expected.Count()); // Verify the correct Number
}
public MovieViewConverter(
ICommonRepository <SentimentDTO> sentimentRepository,
ICommonRepository <MovieDTO> movieRepository,
IOpinionExecution opinitonExecution,
IMapper mapper)
{
_sentimentRepository = sentimentRepository;
_movieRepository = movieRepository;
_opinionExecution = opinitonExecution;
_mapper = mapper;
}
//readonly ICommonRepository<ProviderConfiguration> _providerRepository;
public GetWebRequest(ICommonRepository <RouteConfiguration> routeRepository, ICommonRepository <ThirdPartyAPIConfiguration> thirdPartyCommonRepository,
//ICommonRepository<ProviderConfiguration> providerRepository,
ICommonRepository <ServiceProConfiguration> ServiceProConfiguration,
ICommonRepository <ServiceProviderDetail> serviceProviderDetail)
{
_thirdPartyCommonRepository = thirdPartyCommonRepository;
_routeRepository = routeRepository;
//_providerRepository = providerRepository;
_ServiceProConfiguration = ServiceProConfiguration;
_serviceProviderDetail = serviceProviderDetail;
}
public static UserService Instance(ICommonRepository <User> repository, string loggerPath, Logger logger = null)
{
if (repository == null)
{
throw new Exception("Can not create UserService");
}
_instance.Value._repository = repository;
_instance.Value._logger = logger ?? new Logger(loggerPath);
return(_instance.Value);
}
public CommonService(ILogger <CommonService> logger, IMapper mapper,
IRepository <TlLookup> tlLookupRepository,
IRepository <FunctionLog> functionLogRepository,
ICommonRepository commonRepository)
{
_logger = logger;
_mapper = mapper;
_tlLookupRepository = tlLookupRepository;
_functionLogRepository = functionLogRepository;
_commonRepository = commonRepository;
}
public PlanService(ICommonRepository<Plan> repository)
{
_repository = repository;
}
public KeyPairService(ICommonService commonService, ICommonRepository commonRepository)
{
_commonService = commonService;
_commonRepository = commonRepository;
}
/// <summary>
/// Transaction Currencies API.
/// </summary>
/// <param name="repo">ICommonRepository.</param>
public Currencies(ICommonRepository repo)
{
this.repo = repo;
}
public UserController(ICommonRepository<User> users)
{
userRepository = users;
}
public StudentController(ICommonRepository repo)
{
repository = repo;
}
public GroupService(ICommonRepository<ArticleGroup> repository,ArticleService service)
{
_repository = repository;
_service = service;
}
public InsuranceController(ICommonRepository repo)
{
repository= repo;
}
public DashboardController(ICommonRepository repo)
{
repository = repo;
}
public UsersController(ICommonRepository<User> d)
{
data = d;
}
public ValuesController(ICommonRepository commonRepository)
{
_commonRepository = commonRepository;
}
public MasterService(ICommonRepository commonRepository)
{
_commonRepository = commonRepository;
}
public CompanyController(ICommonRepository repo)
{
repository= repo;
}
