public OpportunityFeed(OpportunityRepository repo, WebSiteFactory siteFactory, ILog logger)
{
this.repo = repo;
this.siteFactory = siteFactory;
this.logger = logger;
webGet = new HtmlWeb();
}
public void GetAllOpportunities_Ok()
{
//Arrange
var jsonDataTable = @"[
{
'OpportunityId': '1',
'OpportunityName': 'Squad Care',
'OpportunityRequirements': '.NET Core',
'DesirableRequirements': 'Conhecimento em Kafka',
'DateRegister': '2021-05-05T00:00:00',
'ClosingDate': '2021-05-05T00:00:00',
'CancellationDate': '2021-05-05T00:00:00',
'OpportunityStatus': true,
'CareerId': '1',
'ServiceId': '1',
'ProfessionalLevelId': '1',
'OpportunityTypeId': '1',
}
]";
_repositoryConnectionMock.Setup(x => x.SearchCommand("GetAllOpportunities", It.IsAny <Dictionary <string, string> >())).Returns(jsonDataTable);
//Action
var repo = new OpportunityRepository(_configurationMock.Object, _careerRepositoryMock.Object, _serviceRepositoryMock.Object,
_professionalLevelRepositoryMock.Object, _opportunityTypeRepository.Object, _repositoryConnectionMock.Object);
var result = repo.GetAllOpportunities();
//Assert
Assert.IsNotNull(result);
}
public async Task Then_Send_Email_To_Providers(
[Frozen] MatchingDbContext dbContext,
IDateTimeProvider dateTimeProvider,
[Frozen] Mapper mapper,
[Frozen] Domain.Models.Opportunity opportunity,
[Frozen] Domain.Models.Provider provider,
[Frozen] Domain.Models.ProviderVenue venue,
[Frozen] BackgroundProcessHistory backgroundProcessHistory,
[Frozen] IEmailService emailService,
ILogger <OpportunityRepository> logger,
ILogger <GenericRepository <BackgroundProcessHistory> > historyLogger,
ILogger <GenericRepository <OpportunityItem> > itemLogger,
ILogger <GenericRepository <FunctionLog> > functionLogLogger
)
{
//Arrange
backgroundProcessHistory.Status = BackgroundProcessHistoryStatus.Pending.ToString();
await DataBuilder.SetTestData(dbContext, provider, venue, opportunity, backgroundProcessHistory);
var repo = new OpportunityRepository(logger, dbContext);
var backgroundRepo = new GenericRepository <BackgroundProcessHistory>(historyLogger, dbContext);
var itemRepo = new GenericRepository <OpportunityItem>(itemLogger, dbContext);
var functionLogRepository = new GenericRepository <FunctionLog>(functionLogLogger, dbContext);
var sut = new ReferralEmailService(mapper, dateTimeProvider, emailService, repo, itemRepo, backgroundRepo, functionLogRepository);
//Act
await sut.SendProviderReferralEmailAsync(opportunity.Id, opportunity.OpportunityItem.Select(oi => oi.Id), backgroundProcessHistory.Id, "System");
//Assert
await emailService.Received(4).SendEmailAsync(Arg.Any <string>(), Arg.Any <string>(), Arg.Any <int?>(), Arg.Any <int?>(), Arg.Any <IDictionary <string, string> >(), Arg.Any <string>());
}
public async Task Then_Send_Email_Is_Called_With_Employer_Details(
[Frozen] MatchingDbContext dbContext,
IDateTimeProvider dateTimeProvider,
[Frozen] Mapper mapper,
[Frozen] Domain.Models.Opportunity opportunity,
[Frozen] Domain.Models.Provider provider,
[Frozen] Domain.Models.ProviderVenue venue,
[Frozen] BackgroundProcessHistory backgroundProcessHistory,
[Frozen] IEmailService emailService,
ILogger <OpportunityRepository> logger,
ILogger <GenericRepository <BackgroundProcessHistory> > historyLogger,
ILogger <GenericRepository <OpportunityItem> > itemLogger,
ILogger <GenericRepository <FunctionLog> > functionLogLogger
)
{
//Arrange
backgroundProcessHistory.Status = BackgroundProcessHistoryStatus.Pending.ToString();
await DataBuilder.SetTestData(dbContext, provider, venue, opportunity, backgroundProcessHistory);
var repo = new OpportunityRepository(logger, dbContext);
var backgroundRepo = new GenericRepository <BackgroundProcessHistory>(historyLogger, dbContext);
var itemRepo = new GenericRepository <OpportunityItem>(itemLogger, dbContext);
var functionLogRepository = new GenericRepository <FunctionLog>(functionLogLogger, dbContext);
var sut = new ReferralEmailService(mapper, dateTimeProvider, emailService, repo, itemRepo, backgroundRepo, functionLogRepository);
//Act
await sut.SendProviderReferralEmailAsync(opportunity.Id, opportunity.OpportunityItem.Select(oi => oi.Id), backgroundProcessHistory.Id, "System");
//Assert
await emailService.Received(4).SendEmailAsync(Arg.Any <string>(), Arg.Any <string>(),
Arg.Any <int?>(), Arg.Any <int?>(),
Arg.Any <IDictionary <string, string> >(),
Arg.Any <string>());
await emailService.Received(4).SendEmailAsync(Arg.Any <string>(), Arg.Any <string>(),
Arg.Any <int?>(), Arg.Any <int?>(),
Arg.Is <IDictionary <string, string> >(tokens =>
tokens.ContainsKey("employer_business_name") && tokens["employer_business_name"] == opportunity.Employer.CompanyName.ToTitleCase()),
Arg.Any <string>());
await emailService.Received(4).SendEmailAsync(Arg.Any <string>(), Arg.Any <string>(),
Arg.Any <int?>(), Arg.Any <int?>(),
Arg.Is <IDictionary <string, string> >(tokens =>
tokens.ContainsKey("employer_contact_name") && tokens["employer_contact_name"] == opportunity.EmployerContact.ToTitleCase()),
Arg.Any <string>());
await emailService.Received(4).SendEmailAsync(Arg.Any <string>(), Arg.Any <string>(),
Arg.Any <int?>(), Arg.Any <int?>(),
Arg.Is <IDictionary <string, string> >(tokens =>
tokens.ContainsKey("employer_contact_number") && tokens["employer_contact_number"] == opportunity.EmployerContactPhone),
Arg.Any <string>());
await emailService.Received(4).SendEmailAsync(Arg.Any <string>(), Arg.Any <string>(),
Arg.Any <int?>(), Arg.Any <int?>(),
Arg.Is <IDictionary <string, string> >(tokens =>
tokens.ContainsKey("employer_contact_email") && tokens["employer_contact_email"] == opportunity.EmployerContactEmail),
Arg.Any <string>());
}
public HttpResponseMessage Post([Bind(Exclude = "Id")][FromBody] Opportunity entity)
{
try
{
if (ModelState.IsValid)
{
OpportunityRepository rep = new OpportunityRepository();
Validate repValid = rep.ValidateInsert(entity);
if (repValid.IsValid)
{
rep.Insert(entity);
return(Request.CreateResponse(HttpStatusCode.OK, "Operação efetuada com sucesso!"));
}
else
{
return(Request.CreateErrorResponse(HttpStatusCode.BadRequest, repValid.Message));
}
}
else
{
return(Request.CreateErrorResponse(HttpStatusCode.BadRequest, ModelState));
}
}
catch (Exception ex)
{
return(Request.CreateResponse(HttpStatusCode.InternalServerError, ex.Message));
}
}
public HttpResponseMessage Get([Bind(Include = "Id")] long Id)
{
try
{
if (ModelState.IsValid)
{
OpportunityRepository rep = new OpportunityRepository();
IEnumerable <Opportunity> list = Mapper.ToList <Opportunity>(rep.GetById(Id));
if (list != null && list.Count() > 0)
{
return(Request.CreateResponse(HttpStatusCode.OK, list.FirstOrDefault()));
}
else
{
return(Request.CreateResponse(HttpStatusCode.NoContent));
}
}
else
{
return(Request.CreateErrorResponse(HttpStatusCode.BadRequest, ModelState));
}
}
catch (Exception ex)
{
return(Request.CreateResponse(HttpStatusCode.InternalServerError, ex.Message));
}
}
public HttpResponseMessage Delete(long Id)
{
try
{
if (Id > 0)
{
OpportunityRepository rep = new OpportunityRepository();
Validate repValid = rep.ValidateDelete(Id);
if (repValid.IsValid)
{
rep.Delete(Id);
return(Request.CreateResponse(HttpStatusCode.OK, "Operação efetuada com sucesso!"));
}
else
{
return(Request.CreateErrorResponse(HttpStatusCode.BadRequest, repValid.Message));
}
}
else
{
return(Request.CreateErrorResponse(HttpStatusCode.BadRequest, "Id inválido!"));
}
}
catch (Exception ex)
{
return(Request.CreateResponse(HttpStatusCode.InternalServerError, ex.Message));
}
}
public void GetOpportunityByName_ArgumentNullException()
{
var opportunityName = "Squad Care";
var repo = new OpportunityRepository(_configurationMock.Object, _careerRepositoryMock.Object, _serviceRepositoryMock.Object,
_professionalLevelRepositoryMock.Object, _opportunityTypeRepository.Object, _repositoryConnectionMock.Object);
var result = repo.GetOpportunityByName(opportunityName);
Assert.IsNull(result);
}
public void DeleteOpportunity_NullReferenceException()
{
var jsonOpportunity = @" ";
var opportunity = JsonConvert.DeserializeObject <Opportunity>(jsonOpportunity);
var repo = new OpportunityRepository(_configurationMock.Object, _careerRepositoryMock.Object, _serviceRepositoryMock.Object,
_professionalLevelRepositoryMock.Object, _opportunityTypeRepository.Object, _repositoryConnectionMock.Object);
repo.DeleteOpportunity(opportunity);
Assert.IsTrue(true);
}
public OpportunityTestFixture()
{
var loggerRepository = new Logger <OpportunityRepository>(new NullLoggerFactory());
var loggerOpportunityItemRepository = new Logger <GenericRepository <OpportunityItem> >(new NullLoggerFactory());
var loggerProvisionGapRepository = new Logger <GenericRepository <ProvisionGap> >(new NullLoggerFactory());
var loggerReferralRepository = new Logger <GenericRepository <Referral> >(new NullLoggerFactory());
MatchingDbContext = new TestConfiguration().GetDbContext();
var opportunityRepository = new OpportunityRepository(loggerRepository, MatchingDbContext);
var opportunityItemRepository = new GenericRepository <OpportunityItem>(loggerOpportunityItemRepository, MatchingDbContext);
var provisionGapRepository = new GenericRepository <ProvisionGap>(loggerProvisionGapRepository, MatchingDbContext);
var referralRepository = new GenericRepository <Referral>(loggerReferralRepository, MatchingDbContext);
var googleMapsApiClient = Substitute.For <IGoogleMapApiClient>();
var opportunityPipelineReportWriter = Substitute.For <IFileWriter <OpportunityReportDto> >();
var dateTimeProvider = Substitute.For <IDateTimeProvider>();
var httpContextAccessor = Substitute.For <IHttpContextAccessor>();
httpContextAccessor.HttpContext.Returns(new DefaultHttpContext
{
User = new ClaimsPrincipal(new ClaimsIdentity(new[]
{
new Claim(ClaimTypes.GivenName, "adminUserName")
}))
});
var config = new MapperConfiguration(c =>
{
c.AddMaps(typeof(OpportunityMapper).Assembly);
c.ConstructServicesUsing(type =>
type.Name.Contains("LoggedInUserEmailResolver") ?
new LoggedInUserEmailResolver <OpportunityDto, Domain.Models.Opportunity>(httpContextAccessor) :
type.Name.Contains("LoggedInUserNameResolver") ?
(object)new LoggedInUserNameResolver <OpportunityDto, Domain.Models.Opportunity>(httpContextAccessor) :
type.Name.Contains("UtcNowResolver") ?
new UtcNowResolver <OpportunityDto, Domain.Models.Opportunity>(new DateTimeProvider()) :
null);
});
var mapper = new Mapper(config);
OpportunityService = new OpportunityService(
mapper,
opportunityRepository,
opportunityItemRepository,
provisionGapRepository,
referralRepository,
googleMapsApiClient,
opportunityPipelineReportWriter,
dateTimeProvider);
}
public OpportunityRepositoryTest()
{
_apiUserRepository = new Mock <IApiUserRepository>(MockBehavior.Strict);
_restRequestBuilder = new Mock <IMinistryPlatformRestRequestBuilderFactory>(MockBehavior.Strict);
_configurationWrapper = new Mock <IConfigurationWrapper>(MockBehavior.Strict);
_restRequest = new Mock <IMinistryPlatformRestRequestBuilder>(MockBehavior.Strict);
_mapper = new Mock <IMapper>(MockBehavior.Strict);
_request = new Mock <IMinistryPlatformRestRequest>();
_fixture = new OpportunityRepository(_restRequestBuilder.Object,
_apiUserRepository.Object,
_configurationWrapper.Object,
_mapper.Object);
}
public void GetAllOpportunities_ArgumentNullException()
{
//Arrange
//Action
var repo = new OpportunityRepository(_configurationMock.Object, _careerRepositoryMock.Object, _serviceRepositoryMock.Object,
_professionalLevelRepositoryMock.Object, _opportunityTypeRepository.Object, _repositoryConnectionMock.Object);
var result = repo.GetAllOpportunities();
//Assert
Assert.IsNull(result);
}
public void GetOpportunityByName_ArgumentException()
{
var jsonDataTable = @"[{}]";
var opportunityName = "Squad Care";
_repositoryConnectionMock.Setup(x => x.SearchCommand("GetOpportunityByName", It.IsAny <Dictionary <string, string> >())).Returns(jsonDataTable);
var repo = new OpportunityRepository(_configurationMock.Object, _careerRepositoryMock.Object, _serviceRepositoryMock.Object,
_professionalLevelRepositoryMock.Object, _opportunityTypeRepository.Object, _repositoryConnectionMock.Object);
var result = repo.GetOpportunityByName(opportunityName);
Assert.IsNull(result);
}
public async Task Then_Send_Email_Is_Called_With_Placements_List(
MatchingDbContext dbContext,
IDateTimeProvider dateTimeProvider,
MapperConfiguration mapperConfiguration,
[Frozen] Domain.Models.Opportunity opportunity,
[Frozen] Domain.Models.Provider provider,
[Frozen] Domain.Models.ProviderVenue venue,
[Frozen] BackgroundProcessHistory backgroundProcessHistory,
[Frozen] IEmailService emailService,
ILogger <OpportunityRepository> logger,
ILogger <GenericRepository <BackgroundProcessHistory> > historyLogger,
ILogger <GenericRepository <OpportunityItem> > itemLogger,
ILogger <GenericRepository <FunctionLog> > functionLogLogger
)
{
//Arrange
backgroundProcessHistory.Status = BackgroundProcessHistoryStatus.Pending.ToString();
await DataBuilder.SetTestData(dbContext, provider, venue, opportunity, backgroundProcessHistory);
var mapper = new Mapper(mapperConfiguration);
var repo = new OpportunityRepository(logger, dbContext);
var backgroundRepo = new GenericRepository <BackgroundProcessHistory>(historyLogger, dbContext);
var itemRepo = new GenericRepository <OpportunityItem>(itemLogger, dbContext);
var functionLogRepository = new GenericRepository <FunctionLog>(functionLogLogger, dbContext);
var sut = new ReferralEmailService(mapper, dateTimeProvider, emailService, repo, itemRepo, backgroundRepo, functionLogRepository);
var itemIds = itemRepo.GetManyAsync(oi => oi.Opportunity.Id == opportunity.Id &&
oi.IsSaved &&
oi.IsSelectedForReferral &&
!oi.IsCompleted).Select(oi => oi.Id);
var expectedResult = await GetExpectedResult(repo, opportunity.Id, itemIds);
//Act
await sut.SendEmployerReferralEmailAsync(opportunity.Id, opportunity.OpportunityItem.Select(oi => oi.Id), backgroundProcessHistory.Id, "System");
//Assert
await emailService.Received(1).SendEmailAsync(Arg.Any <string>(), Arg.Any <string>(), Arg.Any <int?>(), Arg.Any <int?>(),
Arg.Any <IDictionary <string, string> >(), Arg.Any <string>());
await emailService.Received(1).SendEmailAsync(Arg.Any <string>(), Arg.Any <string>(), Arg.Any <int?>(), Arg.Any <int?>(),
Arg.Is <IDictionary <string, string> >(tokens => tokens.ContainsKey("placements_list")), Arg.Any <string>());
await emailService.Received(1).SendEmailAsync(Arg.Any <string>(), Arg.Any <string>(), Arg.Any <int?>(), Arg.Any <int?>(),
Arg.Is <IDictionary <string, string> >(tokens => tokens.ContainsKey("placements_list") && tokens["placements_list"] == expectedResult),
Arg.Any <string>());
}
public void GetAllOpportunities_ArgumentException()
{
//Arrange
var jsonDataTable = @"[{}]";
_repositoryConnectionMock.Setup(x => x.SearchCommand("GetAllOpportunities", It.IsAny <Dictionary <string, string> >())).Returns(jsonDataTable);
//Action
var repo = new OpportunityRepository(_configurationMock.Object, _careerRepositoryMock.Object, _serviceRepositoryMock.Object,
_professionalLevelRepositoryMock.Object, _opportunityTypeRepository.Object, _repositoryConnectionMock.Object);
var result = repo.GetAllOpportunities();
//Assert
Assert.IsNull(result);
}
public void DeleteOpportunity_Exception()
{
var jsonOpportunity = @"{
'OpportunityId': 0
}";
var opportunity = JsonConvert.DeserializeObject <Opportunity>(jsonOpportunity);
_repositoryConnectionMock.Setup(x => x.SimpleExecuteCommand("DeleteOpportunity", It.IsAny <Dictionary <string, string> >())).Throws(new Exception());
var repo = new OpportunityRepository(_configurationMock.Object, _careerRepositoryMock.Object, _serviceRepositoryMock.Object,
_professionalLevelRepositoryMock.Object, _opportunityTypeRepository.Object, _repositoryConnectionMock.Object);
repo.DeleteOpportunity(opportunity);
Assert.IsTrue(true);
}
public When_OpportunityRepository_GetPipelineOpportunities_Is_Called()
{
var logger = Substitute.For <ILogger <OpportunityRepository> >();
using var dbContext = InMemoryDbContext.Create();
dbContext.Add(
new ValidOpportunityBuilder()
.AddEmployer()
.AddReferrals()
.AddProvisionGaps()
.Build());
dbContext.SaveChanges();
var repository = new OpportunityRepository(logger, dbContext);
_result = repository.GetPipelineOpportunitiesAsync(1)
.GetAwaiter().GetResult();
}
public async Task Then_Background_Process_History_Status_Is_Completed(
MatchingDbContext dbContext,
IDateTimeProvider dateTimeProvider,
MapperConfiguration mapperConfiguration,
[Frozen] Domain.Models.Opportunity opportunity,
[Frozen] Domain.Models.Provider provider,
[Frozen] Domain.Models.ProviderVenue venue,
[Frozen] BackgroundProcessHistory backgroundProcessHistory,
[Frozen] IEmailService emailService,
ILogger <OpportunityRepository> logger,
ILogger <GenericRepository <BackgroundProcessHistory> > historyLogger,
ILogger <GenericRepository <OpportunityItem> > itemLogger,
ILogger <GenericRepository <FunctionLog> > functionLogLogger
)
{
//Arrange
backgroundProcessHistory.Status = BackgroundProcessHistoryStatus.Pending.ToString();
await DataBuilder.SetTestData(dbContext, provider, venue, opportunity, backgroundProcessHistory);
var mapper = new Mapper(mapperConfiguration);
var repo = new OpportunityRepository(logger, dbContext);
var backgroundRepo = new GenericRepository <BackgroundProcessHistory>(historyLogger, dbContext);
var itemRepo = new GenericRepository <OpportunityItem>(itemLogger, dbContext);
var functionLogRepository = new GenericRepository <FunctionLog>(functionLogLogger, dbContext);
var sut = new ReferralEmailService(mapper, dateTimeProvider, emailService, repo, itemRepo, backgroundRepo, functionLogRepository);
//Act
await sut.SendEmployerReferralEmailAsync(opportunity.Id, opportunity.OpportunityItem.Select(oi => oi.Id), backgroundProcessHistory.Id, "System");
//Assert
await emailService.Received(1).SendEmailAsync(Arg.Any <string>(), Arg.Any <string>(), Arg.Any <int?>(), Arg.Any <int?>(), Arg.Any <IDictionary <string, string> >(), Arg.Any <string>());
var processStatus = dbContext.BackgroundProcessHistory
.FirstOrDefault(history => history.Id == backgroundProcessHistory.Id)
?.Status;
processStatus.Should().NotBe(BackgroundProcessHistoryStatus.Pending.ToString());
processStatus.Should().NotBe(BackgroundProcessHistoryStatus.Processing.ToString());
processStatus.Should().Be(BackgroundProcessHistoryStatus.Complete.ToString());
}
public HttpResponseMessage Get()
{
try
{
OpportunityRepository rep = new OpportunityRepository();
IEnumerable <Opportunity> list = Mapper.ToList <Opportunity>(rep.GetAll());
if (list != null && list.Count() > 0)
{
return(Request.CreateResponse(HttpStatusCode.OK, list));
}
else
{
return(Request.CreateResponse(HttpStatusCode.NoContent));
}
}
catch (Exception ex)
{
return(Request.CreateResponse(HttpStatusCode.InternalServerError, ex.Message));
}
}
public void UpdateOpportunity_Ok()
{
var jsonOpportunity = @"{
'opportunityId': 1,
'opportunityName': 'Squad Care alterado',
'opportunityRequirements': '.NET Core',
'desirableRequirements': 'Conhecimento em Kafka',
'dateRegister':'2021-05-05',
'closingDate':'2021-05-05',
'cancellationDate':'2021-05-05',
'opportunityStatus': true
}";
var opporunity = JsonConvert.DeserializeObject <Opportunity>(jsonOpportunity);
var repo = new OpportunityRepository(_configurationMock.Object, _careerRepositoryMock.Object, _serviceRepositoryMock.Object,
_professionalLevelRepositoryMock.Object, _opportunityTypeRepository.Object, _repositoryConnectionMock.Object);
repo.UpdateOpportunity(opporunity);
Assert.IsTrue(true);
}
//[InlineData("Test", "Test")]
public async Task AND_Secondary_Contact_Name_or_Email_Is_Invalid_Then_Send_Email_Is_NOT_Called(
string secondaryContactName,
string secondaryContactEmail,
[Frozen] MatchingDbContext dbContext,
IDateTimeProvider dateTimeProvider,
[Frozen] Mapper mapper,
[Frozen] Domain.Models.Opportunity opportunity,
[Frozen] Domain.Models.Provider provider,
[Frozen] Domain.Models.ProviderVenue venue,
[Frozen] BackgroundProcessHistory backgroundProcessHistory,
[Frozen] IEmailService emailService,
ILogger <OpportunityRepository> logger,
ILogger <GenericRepository <BackgroundProcessHistory> > historyLogger,
ILogger <GenericRepository <OpportunityItem> > itemLogger,
ILogger <GenericRepository <FunctionLog> > functionLogLogger
)
{
//Arrange
backgroundProcessHistory.Status = BackgroundProcessHistoryStatus.Pending.ToString();
provider.SecondaryContact = secondaryContactName;
provider.SecondaryContactEmail = secondaryContactEmail;
await DataBuilder.SetTestData(dbContext, provider, venue, opportunity, backgroundProcessHistory);
var repo = new OpportunityRepository(logger, dbContext);
var backgroundRepo = new GenericRepository <BackgroundProcessHistory>(historyLogger, dbContext);
var itemRepo = new GenericRepository <OpportunityItem>(itemLogger, dbContext);
var functionLogRepository = new GenericRepository <FunctionLog>(functionLogLogger, dbContext);
var sut = new ReferralEmailService(mapper, dateTimeProvider, emailService, repo, itemRepo, backgroundRepo, functionLogRepository);
//Act
await sut.SendProviderReferralEmailAsync(opportunity.Id, opportunity.OpportunityItem.Select(oi => oi.Id), backgroundProcessHistory.Id, "System");
//Assert
await emailService.Received(2).SendEmailAsync(Arg.Any <string>(), Arg.Any <string>(), Arg.Any <int?>(), Arg.Any <int?>(),
Arg.Is <IDictionary <string, string> >(tokens => tokens.ContainsKey("employer_business_name")),
Arg.Any <string>());
}
public void UpdateOpportunity_Exception()
{
var jsonOpportunity = @"{
'opportunityId': 1,
'opportunityName': 'Squad Care alterado',
'opportunityRequirements': '.NET Core',
'desirableRequirements': 'Conhecimento em Kafka',
'dateRegister':'2021-05-05',
'closingDate':'2021-05-05',
'cancellationDate':'2021-05-05',
'opportunityStatus': true
}";
var opportunity = JsonConvert.DeserializeObject <Opportunity>(jsonOpportunity);
_repositoryConnectionMock.Setup(x => x.SimpleExecuteCommand("UpdateOpportunity", It.IsAny <Dictionary <string, string> >())).Throws(new Exception());
var repo = new OpportunityRepository(_configurationMock.Object, _careerRepositoryMock.Object, _serviceRepositoryMock.Object,
_professionalLevelRepositoryMock.Object, _opportunityTypeRepository.Object, _repositoryConnectionMock.Object);
repo.UpdateOpportunity(opportunity);
Assert.IsTrue(true);
}
public void InsertOpportunity_Ok()
{
//Arrange
var jsonOpportunity = @"{
'opportunityId': 1,
'opportunityName': 'Squad Care alterado',
'opportunityRequirements': '.NET Core',
'desirableRequirements': 'Conhecimento em Kafka',
'dateRegister': '2021-05-05T00:00:00',
'closingDate': '2021-05-05T00:00:00',
'cancellationDate': '2021-05-05T00:00:00',
'opportunityStatus': false,
'career': {
'careerId': 1
},
'service': {
'serviceId': 1
},
'professionalLevel': {
'professionalLevelId': 1
},
'opportunityType': {
'opportunityTypeId': 1
}
}";
var opportunity = JsonConvert.DeserializeObject <Opportunity>(jsonOpportunity);
//Action
var repo = new OpportunityRepository(_configurationMock.Object, _careerRepositoryMock.Object, _serviceRepositoryMock.Object,
_professionalLevelRepositoryMock.Object, _opportunityTypeRepository.Object, _repositoryConnectionMock.Object);
repo.InsertOpportunity(opportunity);
//Assert
Assert.IsTrue(true);
}
private static Application.Services.EmailDeliveryStatusService SutSetUp(
MatchingDbContext dbContext,
ILogger <OpportunityRepository> opportunityRepoLogger,
ILogger <GenericRepository <EmailTemplate> > emailTemplateLogger,
ILogger <GenericRepository <EmailHistory> > emailHistoryLogger,
ILogger <GenericRepository <FunctionLog> > functionLogLogger,
ILogger <Application.Services.EmailDeliveryStatusService> emailDeliveryServiceStatusLogger,
ILogger <EmailService> emailServiceLogger,
IAsyncNotificationClient notificationClient,
MatchingConfiguration configuration,
IMessageQueueService messageQueueService)
{
var config = new MapperConfiguration(c => c.AddMaps(typeof(EmailService).Assembly));
var mapper = new Mapper(config);
var emailTemplateRepository = new GenericRepository <EmailTemplate>(emailTemplateLogger, dbContext);
var opportunityRepository = new OpportunityRepository(opportunityRepoLogger, dbContext);
var emailHistoryRepository = new GenericRepository <EmailHistory>(emailHistoryLogger, dbContext);
var functionLogRepository = new GenericRepository <FunctionLog>(functionLogLogger, dbContext);
var emailService = new EmailService(configuration, notificationClient, emailTemplateRepository, emailHistoryRepository, functionLogRepository, mapper, emailServiceLogger);
return(new Application.Services.EmailDeliveryStatusService(configuration,
emailService, opportunityRepository, messageQueueService, emailDeliveryServiceStatusLogger));
}
public AssistanceResultViewModel Search(SearchModel searchModel)
{
// Remove unnecessary keywords
var keywordCurator = new KeywordCurator();
var curatedKeywords = keywordCurator.GetCuratedKeywords(searchModel.SplitKeywords);
// Retrieve and filter data
var opportunityRepo = new OpportunityRepository();
var programRepo = new ProgramRepository();
var customOpportunityRepo = new CustomOpportunityRepository();
var fieldCodedValueRepo = new FieldCodedValueRepository();
// Custom Opportunities
var customOpportunityQuery = customOpportunityRepo.GetCustomOpportunitiesByKeywords(curatedKeywords); // Filter by keywords
if (searchModel.AssistanceTypesNames.Count > 0) // Then filter by Assistance Type
{
// Retrieves the coded field names for Custom Opportunities
var getFieldCodes = fieldCodedValueRepo.GetFieldCode(CodedFieldOrigin.BusinessIncentives, searchModel.AssistanceTypesNames).ToList();
if (getFieldCodes != null && getFieldCodes.Count > 0)
{
customOpportunityQuery = customOpportunityRepo.GetCustomOpportunitiesByAssistanceType(getFieldCodes, customOpportunityQuery);
}
}
if (!string.IsNullOrEmpty(searchModel.City))
{
customOpportunityQuery = customOpportunityQuery.Where(co => co.FundingLevelID > 1 ||
co.FundingLevelID == 1 && co.FundingLevelDetails.ToLower().Contains(searchModel.City.ToLower()));
}
// Opportunities
var opportunityQuery = opportunityRepo.GetOpportunitiesByKeywords(curatedKeywords); // Filter by keywords
if (searchModel.AssistanceTypesNames.Count > 0) // Then filter by Assistance Type
{
// Retrieves the coded field names for Custom Opportunities
var getFieldCodes = fieldCodedValueRepo.GetFieldCode(CodedFieldOrigin.GrantsGov, searchModel.AssistanceTypesNames).ToList();
if (getFieldCodes != null && getFieldCodes.Count > 0)
{
opportunityQuery = opportunityRepo.GetOpportunitiesByAssistanceTypeName(getFieldCodes, opportunityQuery);
}
else
{
opportunityQuery = opportunityRepo.GetOpportunitiesByKeywords(searchModel.AssistanceTypesNames);
}
}
// Programs
if (searchModel.AssistanceTypesNames.Count > 0)
{
curatedKeywords.AddRange(searchModel.AssistanceTypesNames);
}
var programs = programRepo.GetProgramsByKeywords(curatedKeywords); // Filter by keywords
// Create and populate viewmodels to return to the view
var mapper = new AssistanceViewModelMapper(fieldCodedValueRepo);
var assistanceResultViewModel = new AssistanceResultViewModel();
var assistanceViewModels = new List <AssistanceViewModel>();
assistanceResultViewModel.CustomOpportunities.AddRange(customOpportunityQuery.ToList().Select(co => mapper.GetFromCustomOpportunity(co)));
assistanceResultViewModel.Opportunities.AddRange(opportunityQuery.ToList().Select(o => mapper.GetFromOpportunity(o)));
assistanceResultViewModel.Programs.AddRange(programs.Select(p => mapper.GetFromProgram(p)));
// Add Keywords
assistanceResultViewModel.CustomOpportunities.ForEach(co => co.Tags = curatedKeywords);
return(assistanceResultViewModel);
}
