public ProviderRepositoryTests() { var mongoDatabase = MongoDbHelper.GetRscueCenterUnitTestDatabase(); _providerRepository = new ProviderRepository(mongoDatabase); _dataStore = new MongoTestDataStore(mongoDatabase); }
public override void Given() { // Seed Tlevel data for pearson SeedTestData(EnumAwardingOrganisation.Pearson, true); var registration = SeedRegistrationData(1111111111); // Assessments seed var tqPathwayAssessmentsSeedData = new List <TqPathwayAssessment>(); tqPathwayAssessmentsSeedData.AddRange(GetPathwayAssessmentsDataToProcess(registration.TqRegistrationPathways.ToList())); SeedPathwayAssessmentsData(tqPathwayAssessmentsSeedData); CreateMapper(); ProviderRepositoryLogger = new Logger <ProviderRepository>(new NullLoggerFactory()); RegistrationRepositoryLogger = new Logger <RegistrationRepository>(new NullLoggerFactory()); TqRegistrationPathwayRepositoryLogger = new Logger <GenericRepository <TqRegistrationPathway> >(new NullLoggerFactory()); TqRegistrationSpecialismRepositoryLogger = new Logger <GenericRepository <TqRegistrationSpecialism> >(new NullLoggerFactory()); ProviderRepository = new ProviderRepository(ProviderRepositoryLogger, DbContext); RegistrationRepository = new RegistrationRepository(RegistrationRepositoryLogger, DbContext); TqRegistrationPathwayRepository = new GenericRepository <TqRegistrationPathway>(TqRegistrationPathwayRepositoryLogger, DbContext); TqRegistrationSpecialismRepository = new GenericRepository <TqRegistrationSpecialism>(TqRegistrationSpecialismRepositoryLogger, DbContext); RegistrationService = new RegistrationService(ProviderRepository, RegistrationRepository, TqRegistrationPathwayRepository, TqRegistrationSpecialismRepository, RegistrationMapper, RegistrationRepositoryLogger); }
public override void Given() { CreateMapper(); // Seed Tlevel data for pearson SeedTestData(EnumAwardingOrganisation.Pearson, true); SeedRegistrationData(1111111111); // Seed Tlevel data for ncfe SeedTestData(EnumAwardingOrganisation.Ncfe, true); SeedRegistrationData(1111111112); SeedRegistrationData(1111111113, RegistrationPathwayStatus.Withdrawn); ProviderRepositoryLogger = new Logger <ProviderRepository>(new NullLoggerFactory()); RegistrationRepositoryLogger = new Logger <RegistrationRepository>(new NullLoggerFactory()); TqRegistrationPathwayRepositoryLogger = new Logger <GenericRepository <TqRegistrationPathway> >(new NullLoggerFactory()); TqRegistrationSpecialismRepositoryLogger = new Logger <GenericRepository <TqRegistrationSpecialism> >(new NullLoggerFactory()); ProviderRepository = new ProviderRepository(ProviderRepositoryLogger, DbContext); RegistrationRepository = new RegistrationRepository(RegistrationRepositoryLogger, DbContext); TqRegistrationPathwayRepository = new GenericRepository <TqRegistrationPathway>(TqRegistrationPathwayRepositoryLogger, DbContext); TqRegistrationSpecialismRepository = new GenericRepository <TqRegistrationSpecialism>(TqRegistrationSpecialismRepositoryLogger, DbContext); RegistrationService = new RegistrationService(ProviderRepository, RegistrationRepository, TqRegistrationPathwayRepository, TqRegistrationSpecialismRepository, RegistrationMapper, RegistrationRepositoryLogger); _tqRegistrationProfilesData = GetRegistrationsDataToProcess(new List <long> { 1111111111, 1111111112, 1111111113 }); _expectedValidationErrors = new BulkRegistrationValidationErrorsBuilder().BuildStage4ValidationErrorsList(); }
public void Execute() { Assert.DoesNotThrowAsync(async() => { var tourRepository = new TourRepository(); var providerRepository = new ProviderRepository(); var apiDownloader = new Mock <IApiDownloader>(); apiDownloader.Setup(p => p.Download()).ReturnsAsync(_availabilityResponse); var logger = Mock.Of <ILogger>(); var importer = new Importer(tourRepository, providerRepository, apiDownloader.Object, logger); await importer.Execute(1); for (int index = 1; index < 3; index++) { var tour = await tourRepository.Get(index); var availabilities = _tourAvailabilities.Where(p => p.TourId == tour.TourId).ToArray(); Assert.AreEqual(availabilities.Length, tour.Availabilities.Count); for (var i = 0; i < availabilities.Length; i++) { var availability = availabilities[i]; var tourAvailability = tour.Availabilities[i]; Assert.AreEqual(availability.AdultPrice, tourAvailability.AdultPrice); Assert.AreEqual(availability.AvailabilityCount, tourAvailability.AvailabilityCount); Assert.AreEqual(availability.StartDate, tourAvailability.StartDate); Assert.AreEqual(availability.TourDuration, tourAvailability.TourDuration); Assert.AreEqual(availability.TourId, tourAvailability.TourId); } } }); }
public ProviderWorkerManager(IHttpContextAccessor httpContextAccessor, AppUserManager appUserManager, IMapper mapper, ILoggerFactory loggerFactory, AppUserRepository appUserRepository, ProviderRepository providerRepository, UserInviteRepository userInviteRepository) : base(httpContextAccessor, appUserManager, mapper, loggerFactory) { _appUserRepository = appUserRepository; _providerRepository = providerRepository; _userInviteRepository = userInviteRepository; }
public override void Given() { // Seed Tlevel data for pearson _uln = 1111111111; SeedTestData(EnumAwardingOrganisation.Pearson, true); SeedRegistrationData(_uln); CreateMapper(); ProviderRepositoryLogger = new Logger <ProviderRepository>(new NullLoggerFactory()); RegistrationRepositoryLogger = new Logger <RegistrationRepository>(new NullLoggerFactory()); TqRegistrationPathwayRepositoryLogger = new Logger <GenericRepository <TqRegistrationPathway> >(new NullLoggerFactory()); TqRegistrationSpecialismRepositoryLogger = new Logger <GenericRepository <TqRegistrationSpecialism> >(new NullLoggerFactory()); ProviderRepository = new ProviderRepository(ProviderRepositoryLogger, DbContext); RegistrationRepository = new RegistrationRepository(RegistrationRepositoryLogger, DbContext); TqRegistrationPathwayRepository = new GenericRepository <TqRegistrationPathway>(TqRegistrationPathwayRepositoryLogger, DbContext); TqRegistrationSpecialismRepository = new GenericRepository <TqRegistrationSpecialism>(TqRegistrationSpecialismRepositoryLogger, DbContext); RegistrationService = new RegistrationService(ProviderRepository, RegistrationRepository, TqRegistrationPathwayRepository, TqRegistrationSpecialismRepository, RegistrationMapper, RegistrationRepositoryLogger); var reregisterTlProvider = TqProviders.Last().TlProvider; var reregisterPathway = TqProviders.Last().TqAwardingOrganisation.TlPathway; var reregisterPathwaySpecialisms = new TlSpecialismBuilder().BuildList(EnumAwardingOrganisation.Pearson, reregisterPathway); _reRegistrationRequest = new ReregistrationRequest { AoUkprn = TlAwardingOrganisation.UkPrn, ProviderUkprn = reregisterTlProvider.UkPrn, AcademicYear = DateTime.UtcNow.Year, CoreCode = reregisterPathway.LarId, SpecialismCodes = reregisterPathwaySpecialisms.Select(s => s.LarId), PerformedBy = "Test User" }; }
private bool ValidateUser(string userName, string passWord, int selectedProvider) { try { var providers = new ProviderRepository().GetAllProviders(); if (providers.Count > 0) { var providerRepository = new ProviderRepository(); if (providerRepository.ValidateUser(userName, passWord, selectedProvider)) { Session["UserName"] = userName; Session["ProviderId"] = selectedProvider; return true; } else { throw new Exception("Invalid username or password"); } } } catch (Exception ex) { throw ex; } return false; }
public override void Given() { CreateMapper(); SeedTestData(EnumAwardingOrganisation.Pearson); ProviderRepositoryLogger = new Logger <ProviderRepository>(new NullLoggerFactory()); RegistrationRepositoryLogger = new Logger <RegistrationRepository>(new NullLoggerFactory()); TqRegistrationPathwayRepositoryLogger = new Logger <GenericRepository <TqRegistrationPathway> >(new NullLoggerFactory()); TqRegistrationSpecialismRepositoryLogger = new Logger <GenericRepository <TqRegistrationSpecialism> >(new NullLoggerFactory()); ProviderRepository = new ProviderRepository(ProviderRepositoryLogger, DbContext); RegistrationRepository = new RegistrationRepository(RegistrationRepositoryLogger, DbContext); TqRegistrationPathwayRepository = new GenericRepository <TqRegistrationPathway>(TqRegistrationPathwayRepositoryLogger, DbContext); TqRegistrationSpecialismRepository = new GenericRepository <TqRegistrationSpecialism>(TqRegistrationSpecialismRepositoryLogger, DbContext); RegistrationService = new RegistrationService(ProviderRepository, RegistrationRepository, TqRegistrationPathwayRepository, TqRegistrationSpecialismRepository, RegistrationMapper, RegistrationRepositoryLogger); _registrationRequest = new RegistrationRequest { AoUkprn = TlAwardingOrganisation.UkPrn, FirstName = "First", LastName = "Last", DateOfBirth = "11/01/1987".ToDateTime(), ProviderUkprn = TlProvider.UkPrn, AcademicYear = DateTime.UtcNow.Year, CoreCode = Pathway.LarId, SpecialismCodes = Specialisms.Select(s => s.LarId), PerformedBy = "Test User" }; }
public void Updates_to_existing_tours_succeed() { //TODO - check values are updated Assert.DoesNotThrowAsync(async() => { var tourRepository = new TourRepository(); var providerRepository = new ProviderRepository(); var logger = new Mock <ILogger>(); var apiDownloader = new Mock <IApiDownloader>(); apiDownloader.Setup(api => api.Download()).ReturnsAsync(_newUpdatesForTour1); var importer = new Importer( tourRepository: tourRepository, providerRepository: providerRepository, apiDownloader: apiDownloader.Object, logger: logger.Object); await importer.Execute(providerId: 1); var tour1 = tourRepository.Get(tourId: 1); tour1.Result.Availabilities.Count.Should().Be(_newUpdatesForTour1.Body.Count); var orderedResults = tour1.Result.Availabilities.OrderBy(a => a.StartDate).ToList(); for (var i = 0; i < _newUpdatesForTour1.Body.Count; i++) { orderedResults[i].StartDate.Should().Be(DateTime.Parse(_newUpdatesForTour1.Body[i].DepartureDate)); //TODO - test the pricing algorithm explicitly orderedResults[i].AdultPrice.Should().Be(_newUpdatesForTour1.Body[i].Price + (_newUpdatesForTour1.Body[i].Price * 0.15m) - (_newUpdatesForTour1.Body[i].Price * 0.95m)); orderedResults[i].TourDuration.Should().Be(_newUpdatesForTour1.Body[i].Nights); orderedResults[i].AvailabilityCount.Should().Be(_newUpdatesForTour1.Body[i].Spaces); } }); }
public ProvidersBL(IUnitOfWork _unitOfWork, IMapper _mapper, IUsersBL _usersBL) { unitOfWork = _unitOfWork; providerRepository = new ProviderRepository(unitOfWork); usersBL = _usersBL; mapper = _mapper; }
public UnitOfWork(ApplicationDbContext context) { _context = context; Utilities = new UtilityRepository(_context); Locations = new LocationRepository(_context); Providers = new ProviderRepository(_context); }
public void GetProviderStandardsByUkprnShouldLogWhenInvalidStatusCode() { var ukprn = 1L; var searchResponse = new Mock <ISearchResponse <ProviderStandardDto> >(); var apiCall = new Mock <IApiCallDetails>(); apiCall.SetupGet(x => x.HttpStatusCode).Returns((int)HttpStatusCode.Ambiguous); searchResponse.SetupGet(x => x.ApiCall).Returns(apiCall.Object); _elasticClient.Setup(x => x.Search(It.IsAny <Func <SearchDescriptor <ProviderStandardDto>, ISearchRequest> >(), It.IsAny <string>())).Returns(searchResponse.Object); var repo = new ProviderRepository( _elasticClient.Object, _log.Object, Mock.Of <IConfigurationSettings>(), Mock.Of <IProviderLocationSearchProvider>(), Mock.Of <IProviderMapping>(), _queryHelper.Object, _mockActiveFrameworkChecker.Object, _mockPaginationHelper.Object); Assert.Throws <ApplicationException>(() => repo.GetStandardsByProviderUkprn(ukprn)); var message = $"httpStatusCode was {(int)HttpStatusCode.Ambiguous} when querying provider standards for ukprn [{ukprn}]"; _log.Verify(x => x.Log(Microsoft.Extensions.Logging.LogLevel.Warning, It.IsAny <EventId>(), It.Is <FormattedLogValues>(a => a.ToString() == message), It.IsAny <Exception>(), It.IsAny <Func <object, Exception, string> >()), Times.Once); }
public override void Given() { // Seed Tlevel data for pearson _uln = 1111111111; SeedTestData(EnumAwardingOrganisation.Pearson, true); _tqRegistrationProfile = SeedRegistrationData(_uln); CreateMapper(); ProviderRepositoryLogger = new Logger <ProviderRepository>(new NullLoggerFactory()); RegistrationRepositoryLogger = new Logger <RegistrationRepository>(new NullLoggerFactory()); TqRegistrationPathwayRepositoryLogger = new Logger <GenericRepository <TqRegistrationPathway> >(new NullLoggerFactory()); TqRegistrationSpecialismRepositoryLogger = new Logger <GenericRepository <TqRegistrationSpecialism> >(new NullLoggerFactory()); ProviderRepository = new ProviderRepository(ProviderRepositoryLogger, DbContext); RegistrationRepository = new RegistrationRepository(RegistrationRepositoryLogger, DbContext); TqRegistrationPathwayRepository = new GenericRepository <TqRegistrationPathway>(TqRegistrationPathwayRepositoryLogger, DbContext); TqRegistrationSpecialismRepository = new GenericRepository <TqRegistrationSpecialism>(TqRegistrationSpecialismRepositoryLogger, DbContext); RegistrationService = new RegistrationService(ProviderRepository, RegistrationRepository, TqRegistrationPathwayRepository, TqRegistrationSpecialismRepository, RegistrationMapper, RegistrationRepositoryLogger); var newProvider = TlProviders.Last(); _updateRegistrationRequest = new ManageRegistration { ProfileId = _profileId, Uln = _uln, FirstName = "John", LastName = "Smith", DateOfBirth = DateTime.UtcNow.AddYears(-20), AoUkprn = TlAwardingOrganisation.UkPrn, ProviderUkprn = newProvider.UkPrn, CoreCode = Pathway.LarId, SpecialismCodes = new List <string>(), PerformedBy = "Test User", HasProviderChanged = false }; }
void IUnitOfWork.InitializeRepositories() { userRepository = (UserRepository)base.Factory.RepositoryFactory.CreateRepository(typeof(UserRepository)); providerRepository = (ProviderRepository)base.Factory.RepositoryFactory.CreateRepository(typeof(ProviderRepository)); userRepository.DataContext = base.Context; providerRepository.DataContext = base.Context; }
public ActionResult UploadImagesProvoder(ProviderModel model) { if (model == null) { model = new ProviderModel(); } string imageURL = string.Empty; string imageName = string.Empty; string path = string.Empty; string imgPath = string.Empty; Response <string> returnModel = new Response <string>(); if (!string.IsNullOrEmpty(model.image) && !string.IsNullOrEmpty(model.image_extension)) { imageName = DateTime.Now.ToString("yyyyMMddHHmmss") + "." + model.image_extension; if (model.image_extension.ToLower() != "jpg" && model.image_extension.ToLower() != "jpeg" && model.image_extension.ToLower() != "png") { returnModel.success = false; returnModel.status = (int)EnumClass.ResponseState.ResposityError; returnModel.msg = Resource_Kharban.SelectImageValidation; return(Ok(returnModel)); } if (model.ImageType == "profile") { path = hostingEnvironment.WebRootPath + "/images/provider_profile"; //Path imageURL = "https://kharban.net:2096/images/provider_profile/" + imageName; } else if (model.ImageType == "iban") { path = hostingEnvironment.WebRootPath + "/images/provider_iban"; //Path imageURL = "https://kharban.net:2096/images/provider_iban/" + imageName; } else if (model.ImageType == "document") { path = hostingEnvironment.WebRootPath + "/images/provider_document"; //Path imageURL = "https://kharban.net:2096/images/provider_document/" + imageName; } //Check if directory exist if (!System.IO.Directory.Exists(path)) { System.IO.Directory.CreateDirectory(path); //Create directory if it doesn't exist } //set the image path imgPath = Path.Combine(path, imageName); } else { returnModel.msg = Resource_Kharban.Error; return(Ok(returnModel)); } returnModel = new ProviderRepository().UploadProviderImage(model, imageURL, imgPath); return(Ok(returnModel)); }
public ActionResult Login() { var providers = new ProviderRepository().GetAllProviders(); var loginViewModel = new LoginModel(); loginViewModel.Providers = new Models.DrodownItemsViewModel(); loginViewModel.Providers.Items = GetProviders(); return View(loginViewModel); }
public ProviderUserManager(IHttpContextAccessor httpContextAccessor, AppUserManager appUserManager, IMapper mapper, ILoggerFactory loggerFactory, ProviderRepository providerRepository, AppUserRepository appUserRepository, EmailSendTaskRepository emailSendTaskRepository, TemplateParser templateParser) : base(httpContextAccessor, appUserManager, mapper, loggerFactory) { _providerRepository = providerRepository; _appUserRepository = appUserRepository; _emailSendTaskRepository = emailSendTaskRepository; _templateParser = templateParser; }
/// <summary> /// Configures the item repositories. /// </summary> /// <returns>Task.</returns> private async Task ConfigureItemRepositories() { await ItemRepository.Initialize().ConfigureAwait(false); await ProviderRepository.Initialize().ConfigureAwait(false); ((LibraryManager)LibraryManager).ItemRepository = ItemRepository; }
public override void Given() { _ulns = new Dictionary <long, RegistrationPathwayStatus> { { 1111111111, RegistrationPathwayStatus.Active }, { 1111111112, RegistrationPathwayStatus.Withdrawn }, { 1111111113, RegistrationPathwayStatus.Active }, { 1111111114, RegistrationPathwayStatus.Active }, }; // Seed data SeedTestData(EnumAwardingOrganisation.Pearson, true); _registrations = SeedRegistrationsDataByStatus(_ulns, TqProvider); var tqPathwayAssessmentsSeedData = new List <TqPathwayAssessment>(); var tqPathwayResultsSeedData = new List <TqPathwayResult>(); var industryPlacementUln = 1111111114; foreach (var registration in _registrations.Where(x => x.UniqueLearnerNumber != industryPlacementUln)) { var isLatestActive = _ulns[registration.UniqueLearnerNumber] != RegistrationPathwayStatus.Withdrawn; var pathwayAssessments = GetPathwayAssessmentsDataToProcess(registration.TqRegistrationPathways.ToList(), isLatestActive); tqPathwayAssessmentsSeedData.AddRange(pathwayAssessments); // Seed Pathway results foreach (var assessment in pathwayAssessments) { var hasHitoricData = new List <long> { 1111111113 }; var isHistoricAssessent = hasHitoricData.Any(x => x == registration.UniqueLearnerNumber); var isLatestActiveResult = !isHistoricAssessent; var tqPathwayResultSeedData = GetPathwayResultDataToProcess(assessment, isLatestActiveResult, isHistoricAssessent); tqPathwayResultsSeedData.AddRange(tqPathwayResultSeedData); } } SeedPathwayAssessmentsData(tqPathwayAssessmentsSeedData, true); SeedIndustryPlacementData(industryPlacementUln, addToDbContext: true); foreach (var profile in _registrations) { SeedQualificationAchievedData(profile); } CreateMapper(); ProviderRepositoryLogger = new Logger <ProviderRepository>(new NullLoggerFactory()); RegistrationRepositoryLogger = new Logger <RegistrationRepository>(new NullLoggerFactory()); TqRegistrationPathwayRepositoryLogger = new Logger <GenericRepository <TqRegistrationPathway> >(new NullLoggerFactory()); TqRegistrationSpecialismRepositoryLogger = new Logger <GenericRepository <TqRegistrationSpecialism> >(new NullLoggerFactory()); ProviderRepository = new ProviderRepository(ProviderRepositoryLogger, DbContext); RegistrationRepository = new RegistrationRepository(RegistrationRepositoryLogger, DbContext); TqRegistrationPathwayRepository = new GenericRepository <TqRegistrationPathway>(TqRegistrationPathwayRepositoryLogger, DbContext); TqRegistrationSpecialismRepository = new GenericRepository <TqRegistrationSpecialism>(TqRegistrationSpecialismRepositoryLogger, DbContext); RegistrationService = new RegistrationService(ProviderRepository, RegistrationRepository, TqRegistrationPathwayRepository, TqRegistrationSpecialismRepository, RegistrationMapper, RegistrationRepositoryLogger); }
public void GetProviderStandardsByUkprn() { var ukprn = 1L; var numberReturnedActiveAndPublished = 4; var searchResponseForDtos = new Mock <ISearchResponse <ProviderStandardDto> >(); var apiCallForDtos = new Mock <IApiCallDetails>(); var searchResponse = new Mock <ISearchResponse <ProviderStandard> >(); var apiCallForFrameworks = new Mock <IApiCallDetails>(); searchResponseForDtos.Setup(x => x.Documents) .Returns(new List <ProviderStandardDto> { new ProviderStandardDto() }); var providerStandards = new List <ProviderStandard> { new ProviderStandard { StandardId = 1, Published = true }, new ProviderStandard { StandardId = 2, Published = true }, new ProviderStandard { StandardId = 3, Published = true }, new ProviderStandard { StandardId = 4, Published = true }, new ProviderStandard { StandardId = 5, Published = false } }; searchResponse.Setup(x => x.Documents).Returns(providerStandards); apiCallForDtos.SetupGet(x => x.HttpStatusCode).Returns((int)HttpStatusCode.OK); searchResponseForDtos.SetupGet(x => x.ApiCall).Returns(apiCallForDtos.Object); apiCallForFrameworks.SetupGet(x => x.HttpStatusCode).Returns((int)HttpStatusCode.OK); searchResponse.SetupGet(x => x.ApiCall).Returns(apiCallForFrameworks.Object); _elasticClient.Setup(x => x.Search(It.IsAny <Func <SearchDescriptor <ProviderStandardDto>, ISearchRequest> >(), It.IsAny <string>())).Returns(searchResponseForDtos.Object); _elasticClient.Setup(x => x.Search(It.IsAny <Func <SearchDescriptor <ProviderStandard>, ISearchRequest> >(), It.IsAny <string>())).Returns(searchResponse.Object); var repo = new ProviderRepository( _elasticClient.Object, _log.Object, Mock.Of <IConfigurationSettings>(), Mock.Of <IProviderLocationSearchProvider>(), Mock.Of <IProviderMapping>(), _queryHelper.Object, _mockActiveFrameworkChecker.Object, _mockPaginationHelper.Object); var result = repo.GetStandardsByProviderUkprn(ukprn); Assert.AreEqual(numberReturnedActiveAndPublished, result.Count()); _log.Verify(x => x.Log(Microsoft.Extensions.Logging.LogLevel.Warning, It.IsAny <EventId>(), It.IsAny <FormattedLogValues>(), It.IsAny <Exception>(), It.IsAny <Func <object, Exception, string> >()), Times.Never); }
private ProviderRepositoryFactory() { this._Cache = new Dictionary <string, object>(); ProviderRepository repository = new ProviderRepository(); ProviderRepositoryInfo info = repository.GetProviderRepositoryInfo(Key); providerSettings = info.ProviderSettings; defaultProviderName = info.DefaultProviderName; }
public UnitOfWork(ApplicationDbContext context) { _context = context; Products = new ProductsRepository(_context); Clients = new ClientsRepository(_context); Configuration = new ConfigurationRepository(_context); Provider = new ProviderRepository(_context); Sale = new SaleRepository(_context); }
public async Task <IActionResult> Post([FromBody] ProjectType projectType) { if (projectType is null) { return(ErrorResult .BadRequest("Request body must not be empty.", ResultErrorCode.ValidationError) .ToActionResult()); } if (!projectType.TryValidate(out var validationResult, serviceProvider: HttpContext.RequestServices)) { return(ErrorResult .BadRequest(validationResult) .ToActionResult()); } var projectTypeDocument = await projectTypeRepository .GetAsync(projectType.Id) .ConfigureAwait(false); if (projectTypeDocument != null) { return(ErrorResult .Conflict($"A ProjectType with id '{projectType.Id}' already exists. Please try your request again with a unique id or call PUT to update the existing ProjectType.") .ToActionResult()); } var providers = await ProviderRepository .ListAsync(includeServiceProviders : false) .ToListAsync() .ConfigureAwait(false); var validProviders = projectType.Providers .All(p => providers.Any(provider => provider.Id == p.Id)); if (!validProviders) { var validProviderIds = string.Join(", ", providers.Select(p => p.Id)); return(ErrorResult .BadRequest(new ValidationError { Field = "projectType", Message = $"All provider ids on a ProjectType must match the id of a registered Provider on the TeamCloud instance and cannot be a Service Provider. Valid provider ids are: {validProviderIds}" }) .ToActionResult()); } var currentUser = await UserService .CurrentUserAsync() .ConfigureAwait(false); projectTypeDocument = new ProjectTypeDocument() .PopulateFromExternalModel(projectType); return(await Orchestrator .InvokeAndReturnActionResultAsync <ProjectTypeDocument, ProjectType>(new OrchestratorProjectTypeCreateCommand(currentUser, projectTypeDocument), Request) .ConfigureAwait(false)); }
public void Initialize() { _connection = DbConnectionFactory.CreateTransient(); _databaseDbContext = new StorageDbContext(_connection); TestDbMigration.Seed(_databaseDbContext); _repository = new ProviderRepository(_databaseDbContext); }
public override void Given() { SeedTestData(); CreateMapper(); ProviderRepositoryLogger = new Logger <ProviderRepository>(new NullLoggerFactory()); ProviderRepository = new ProviderRepository(ProviderRepositoryLogger, DbContext); TlProviderRepositoryLogger = new Logger <GenericRepository <TlProvider> >(new NullLoggerFactory()); TlproviderRepository = new GenericRepository <TlProvider>(TlProviderRepositoryLogger, DbContext); ProviderService = new ProviderService(ProviderRepository, TlproviderRepository, ProviderMapper, Logger); }
public ProviderManager(IHttpContextAccessor httpContextAccessor, AppUserManager appUserManager, IMapper mapper, ILoggerFactory loggerFactory, ProviderRepository providerRepository, ProviderCategoryRepository providerCategoryRepository, ProviderTagRepository providerTagRepository, ImageTmpBucket imageTmpBucket, ImageOriginBucket imageOriginBucket) : base(httpContextAccessor, appUserManager, mapper, loggerFactory) { _providerRepository = providerRepository; _providerTagRepository = providerTagRepository; _providerCategoryRepository = providerCategoryRepository; _imageTmpBucket = imageTmpBucket; _imageOriginBucket = imageOriginBucket; }
public App(string displayText) { _displayText = displayText; InitializeComponent(); CountPlanRepo = new CountPlanRepository(displayText); ProviderRepo = new ProviderRepository(displayText); OrderRepo = new OrderRepository(displayText); MainPage = new MainPage(); }
public override void Given() { SeedTestData(); ProviderRepositoryLogger = Substitute.For <ILogger <ProviderRepository> >(); ProviderRepository = new ProviderRepository(ProviderRepositoryLogger, DbContext); TlProviderRepositoryLogger = Substitute.For <ILogger <GenericRepository <TlProvider> > >(); TlproviderRepository = new GenericRepository <TlProvider>(TlProviderRepositoryLogger, DbContext); ProviderService = new ProviderService(ProviderRepository, TlproviderRepository, ProviderMapper, Logger); }
public IActionResult ViewProvider([FromBody] ProviderModel model) { if (model == null) { model = new ProviderModel(); } Response <ProviderModel> returnModel = new ProviderRepository().GetProvider(model); return(Ok(returnModel)); }
public IActionResult GetProviderRequestList([FromBody] RequestModel model) { if (model == null) { model = new RequestModel(); } ResponseList <List <ProviderModel> > returnModel = new ProviderRepository().GetProviderRequestList(model); return(Ok(returnModel)); }
public IActionResult UpdateStatusProvider([FromBody] ProviderModel model) { if (model == null) { model = new ProviderModel(); } Response <ProviderModel> returnModel = new ProviderRepository().UpdateProviderStatus(model); return(Ok(returnModel)); }
private List<SelectListItem> GetProviders() { var providersList = new ProviderRepository().GetAllProviders(); var selectedListItems = new List<SelectListItem>(); foreach (var provider in providersList) { selectedListItems.Add(new SelectListItem { Text = provider.ProviderName, Value = provider.ProviderId.ToString() }); } return selectedListItems; }
public Provider GetById(int ProviderId) { var Provider = ProviderRepository.GetById(ProviderId); if (Provider == null) { throw new BadRequestException(ErrorMessages.TrabajadorNoEncontrado); } return(Provider); }
public ActionResult ProviderRegistration(ProviderViewModel providerViewModel) { if (!ModelState.IsValid) { return View(providerViewModel); } try { HealthReunionDataAccess.HealthReunionEntities dataContext = new HealthReunionDataAccess.HealthReunionEntities(); ProviderRepository providerRepository = new ProviderRepository(); var provider = new Provider { ProviderName = providerViewModel.ProviderName, TermsOfUse = providerViewModel.TermsOfUse.Trim(), ProviderDescription = providerViewModel.ProviderDescription.Trim(), PrivacyStatement = providerViewModel.PrivacyStatement.Trim(), AuthorizationReason = providerViewModel.AuthorizationReason.Trim(), Email = providerViewModel.Email.Trim() }; var user = new User { UserName = providerViewModel.UserName.Trim(), Password = providerViewModel.Password.Trim(), ProviderId = provider.ProviderId }; providerRepository.AddProviderWithDefaultUser(provider, user); } catch (Exception ex) { ModelState.AddModelError("", ex.Message); return View(providerViewModel); } ViewBag.Message = string.Format("Provider '{0}' Created Sucessfully!", providerViewModel.ProviderName); return View(new ProviderViewModel()); }