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