public When_OpportunityService_Is_Called_To_Get_Opportunity_Basket_ReferralSingleOnly()
{
var config = new MapperConfiguration(c => c.AddMaps(typeof(OpportunityMapper).Assembly));
var mapper = new Mapper(config);
_opportunityRepository = Substitute.For <IOpportunityRepository>();
var opportunityItemRepository = Substitute.For <IRepository <OpportunityItem> >();
var provisionGapRepository = Substitute.For <IRepository <ProvisionGap> >();
var referralRepository = Substitute.For <IRepository <Domain.Models.Referral> >();
var googleMapApiClient = Substitute.For <IGoogleMapApiClient>();
var opportunityPipelineReportWriter = Substitute.For <IFileWriter <OpportunityReportDto> >();
var dateTimeProvider = Substitute.For <IDateTimeProvider>();
var viewModel = new OpportunityBasketViewModelBuilder()
.AddReferralItem()
.Build();
_opportunityRepository.GetOpportunityBasketAsync(1).Returns(viewModel);
var opportunityService = new OpportunityService(mapper, _opportunityRepository, opportunityItemRepository,
provisionGapRepository, referralRepository, googleMapApiClient,
opportunityPipelineReportWriter, dateTimeProvider);
_result = opportunityService.GetOpportunityBasketAsync(1)
.GetAwaiter().GetResult();
}
public When_OpportunityService_Is_Called_To_Delete_UnSaved_Opportunity()
{
var mapper = new Mapper(Substitute.For <IConfigurationProvider>());
_opportunityRepository = Substitute.For <IOpportunityRepository>();
_opportunityItemRepository = Substitute.For <IRepository <OpportunityItem> >();
_provisionGapRepository = Substitute.For <IRepository <ProvisionGap> >();
_referralRepository = Substitute.For <IRepository <Domain.Models.Referral> >();
_opportunityItemRepository
.GetManyAsync(Arg.Any <Expression <Func <OpportunityItem, bool> > >())
.Returns(SetOpportunityItem().AsQueryable());
_referralRepository
.GetManyAsync(Arg.Any <Expression <Func <Domain.Models.Referral, bool> > >())
.Returns(SetReferrals().AsQueryable());
_provisionGapRepository
.GetManyAsync(Arg.Any <Expression <Func <ProvisionGap, bool> > >())
.Returns(SetProvisionGaps().AsQueryable());
var googleMapApiClient = Substitute.For <IGoogleMapApiClient>();
var opportunityPipelineReportWriter = Substitute.For <IFileWriter <OpportunityReportDto> >();
var dateTimeProvider = Substitute.For <IDateTimeProvider>();
var opportunityService = new OpportunityService(mapper, _opportunityRepository, _opportunityItemRepository,
_provisionGapRepository, _referralRepository, googleMapApiClient,
opportunityPipelineReportWriter, dateTimeProvider);
opportunityService.DeleteOpportunityItemAsync(OpportunityId, OpportunityItemId).GetAwaiter().GetResult();
}
public JsonResult CreateOpportunity(Opportunity opportunity)
{
//var newOpportunityId = OpportunityService.CreateOpporutnity(GetService(), opportunity);
var newOpportunityId = OpportunityService.CreateOpporutnity(GetHttpClient(), opportunity);
return(Json(newOpportunityId, JsonRequestBehavior.AllowGet));
}
public When_OpportunityService_Is_Called_To_Delete_Referral()
{
var config = new MapperConfiguration(c => c.AddMaps(typeof(OpportunityMapper).Assembly));
var mapper = new Mapper(config);
var opportunityRepository = Substitute.For <IOpportunityRepository>();
var opportunityItemRepository = Substitute.For <IRepository <OpportunityItem> >();
var provisionGapRepository = Substitute.For <IRepository <ProvisionGap> >();
_referralRepository = Substitute.For <IRepository <Domain.Models.Referral> >();
_referralRepository.GetFirstOrDefaultAsync(Arg.Any <Expression <Func <Domain.Models.Referral, bool> > >())
.Returns(new Domain.Models.Referral
{
Id = ReferralId,
OpportunityItemId = OpportunityItemId
});
var googleMapApiClient = Substitute.For <IGoogleMapApiClient>();
var opportunityPipelineReportWriter = Substitute.For <IFileWriter <OpportunityReportDto> >();
var dateTimeProvider = Substitute.For <IDateTimeProvider>();
var opportunityService = new OpportunityService(mapper, opportunityRepository, opportunityItemRepository,
provisionGapRepository, _referralRepository, googleMapApiClient,
opportunityPipelineReportWriter, dateTimeProvider);
opportunityService.DeleteReferralAsync(ReferralId).GetAwaiter().GetResult();
}
public JsonResult GetOpportunitiesProductsByCustomerIdByInspectionId(Guid opportunityId)
{
var opportunities =
OpportunityService.QueryOpportunityProductsByOpportunityId(GetHttpClient(), opportunityId);
return(Json(opportunities, JsonRequestBehavior.AllowGet));
}
public When_OpportunityService_Is_Called_To_Save_EmployerDetail()
{
var config = new MapperConfiguration(c => c.AddMaps(typeof(OpportunityMapper).Assembly));
var mapper = new Mapper(config);
_opportunityRepository = Substitute.For <IOpportunityRepository>();
var opportunityItemRepository = Substitute.For <IRepository <OpportunityItem> >();
var provisionGapRepository = Substitute.For <IRepository <ProvisionGap> >();
var referralRepository = Substitute.For <IRepository <Domain.Models.Referral> >();
var googleMapApiClient = Substitute.For <IGoogleMapApiClient>();
var opportunityPipelineReportWriter = Substitute.For <IFileWriter <OpportunityReportDto> >();
var dateTimeProvider = Substitute.For <IDateTimeProvider>();
_opportunityRepository.GetSingleOrDefaultAsync(Arg.Any <Expression <Func <Domain.Models.Opportunity, bool> > >()).Returns(new Domain.Models.Opportunity {
Id = OpportunityId
});
var opportunityService = new OpportunityService(mapper, _opportunityRepository, opportunityItemRepository,
provisionGapRepository, referralRepository, googleMapApiClient,
opportunityPipelineReportWriter, dateTimeProvider);
var dto = new EmployerDetailDto
{
OpportunityId = OpportunityId,
PrimaryContact = Contact,
Email = ContactEmail,
Phone = ContactPhone,
ModifiedBy = ModifiedBy
};
opportunityService.UpdateOpportunityAsync(dto).GetAwaiter().GetResult();
}
public async void TestPut()
{
using (var client = server.CreateClient().AcceptJson())
{
var service = new OpportunityService();
var item = service.GetAll().FirstOrDefault();
if (item == null)
{
this.TestPost();
item = service.GetAll().FirstOrDefault();
}
var itemId = item.Id;
string unique = (Guid.NewGuid()).ToString();
item.Name = unique;
var response = await client.PutAsJsonAsync(string.Format("/api/Opportunitys/{0}", itemId), item);
var result = await response.Content.ReadAsJsonAsync <Opportunity>();
item = service.GetById(itemId);
Assert.True(item.Name.Equals(unique, StringComparison.OrdinalIgnoreCase));
Assert.Equal((int)response.StatusCode, 200);
}
}
public async void TestPost()
{
using (var client = server.CreateClient().AcceptJson())
{
var step = 1;
var service = new OpportunityService();
var countBefore = service.GetAll().Count();
var item = service.GetAll().FirstOrDefault();
if (item == null)
{
var newItem = new Opportunity()
{
Id = 0,
Name = string.Format("Opportunity {0}", countBefore)
};
service.Add(item);
item = service.GetAll().FirstOrDefault();
step = 2;
}
var response = await client.PostAsJsonAsync("/api/Opportunitys", item);
var result = await response.Content.ReadAsJsonAsync <Opportunity>();
var countAfter = service.GetAll().Count();
Assert.Equal(countBefore, countAfter - step);
Assert.Equal((int)response.StatusCode, 201);
}
}
public JsonResult CreateOpportunityProduct(OpportunityProduct opportunityProduct)
{
var newOpportunityProductId =
OpportunityService.CreateOpportunityProduct(GetHttpClient(), opportunityProduct);
return(Json(newOpportunityProductId, JsonRequestBehavior.AllowGet));
}
/// <summary>
/// Create an opportunity
/// </summary>
/// <param name="ownerPartyId"></param>
/// <param name="orgExternalRef"></param>
/// <param name="contactExternalRef"></param>
/// <param name="name"></param>
/// <returns></returns>
public long?CreateOpportunity(long?ownerPartyId, long?orgExternalRef, long?contactExternalRef, string name)
{
IOpportunityService service = OpportunityService.GetService();
OpportunityModel model = new OpportunityModel();
model.Name = name;
if (orgExternalRef != null)
{
model.TargetPartyId = (long)orgExternalRef;
model.TargetPartyIdSpecified = true;
}
model.OwnerResourcePartyId = (long)ownerPartyId;
model.OwnerResourcePartyIdSpecified = true;
model.KeyContactId = contactExternalRef;
model.KeyContactIdSpecified = true;
OpportunityResourceModel resourceModel = new OpportunityResourceModel();
resourceModel.OwnerFlag = true;
resourceModel.OwnerFlagSpecified = true;
resourceModel.ResourceId = (long)ownerPartyId;
resourceModel.ResourceIdSpecified = true;
model.OpportunityResourceModel = resourceModel;
OpportunityModel result = service.CreateOpportunity(model);
if (result != null && result.OpportunityId != null)
{
return(result.OpportunityId);
}
return(null);
}
public When_OpportunityService_Is_Called_To_Save_PlacementInformation_With_Empty_Job_Title()
{
var config = new MapperConfiguration(c => c.AddMaps(typeof(OpportunityMapper).Assembly));
var mapper = new Mapper(config);
_opportunityItemRepository = Substitute.For <IRepository <OpportunityItem> >();
var opportunityRepository = Substitute.For <IOpportunityRepository>();
var provisionGapRepository = Substitute.For <IRepository <ProvisionGap> >();
var referralRepository = Substitute.For <IRepository <Domain.Models.Referral> >();
var googleMapApiClient = Substitute.For <IGoogleMapApiClient>();
var opportunityPipelineReportWriter = Substitute.For <IFileWriter <OpportunityReportDto> >();
var dateTimeProvider = Substitute.For <IDateTimeProvider>();
var opportunityItem = new OpportunityItem {
Id = OpportunityItemId, Postcode = Postcode, SearchRadius = Distance, RouteId = RouteId
};
_opportunityItemRepository.GetSingleOrDefaultAsync(Arg.Any <Expression <Func <OpportunityItem, bool> > >()).Returns(opportunityItem);
var opportunityService = new OpportunityService(mapper, opportunityRepository, _opportunityItemRepository,
provisionGapRepository, referralRepository, googleMapApiClient,
opportunityPipelineReportWriter, dateTimeProvider);
var dto = new PlacementInformationSaveDto
{
OpportunityItemId = OpportunityItemId,
JobRole = JobRole,
PlacementsKnown = PlacementsKnown,
Placements = Placements
};
opportunityService.UpdateOpportunityItemAsync(dto).GetAwaiter().GetResult();
}
public async Task Then_Reasons_Should_Have_Only_Related_To_No_Suitable_Students(
MatchingDbContext dbContext,
OpportunityItem opportunityItem,
IMapper mapper,
[Frozen] ILogger <OpportunityRepository> logger,
[Frozen] IRepository <OpportunityItem> opportunityItemRepository,
[Frozen] IRepository <ProvisionGap> provisionGapRepository,
[Frozen] IRepository <Domain.Models.Referral> referralRepository,
[Frozen] IGoogleMapApiClient googleMapApiClient,
[Frozen] IFileWriter <OpportunityReportDto> opportunityPipelineReportWriter,
[Frozen] IDateTimeProvider dateTimeProvider
)
{
await SetProvisionGapData(dbContext, opportunityItem, false, true, false);
var opportunityRepository = new OpportunityRepository(logger, dbContext);
var sut = new OpportunityService(mapper, opportunityRepository, opportunityItemRepository,
provisionGapRepository, referralRepository, googleMapApiClient,
opportunityPipelineReportWriter, dateTimeProvider);
var result = await sut.GetOpportunityBasketAsync(opportunityItem.OpportunityId);
result.ProvisionGapItems.Should().Contain(model => model.OpportunityType == "ProvisionGap").Which.Reason
.Should().Contain("Providers do not have students doing the right course");
result.ProvisionGapItems.Should().Contain(model => model.OpportunityType == "ProvisionGap").Which.Reason
.Should().NotContain("Employer had a bad experience with them");
}
public When_OpportunityService_Is_Called_To_Get_Opportunity_Spreadsheet_Data()
{
var config = new MapperConfiguration(c => c.AddMaps(typeof(OpportunityMapper).Assembly));
var mapper = new Mapper(config);
_opportunityRepository = Substitute.For <IOpportunityRepository>();
var opportunityItemRepository = Substitute.For <IRepository <OpportunityItem> >();
var provisionGapRepository = Substitute.For <IRepository <ProvisionGap> >();
var referralRepository = Substitute.For <IRepository <Domain.Models.Referral> >();
var googleMapApiClient = Substitute.For <IGoogleMapApiClient>();
_opportunityPipelineReportWriter = Substitute.For <IFileWriter <OpportunityReportDto> >();
var dateTimeProvider = Substitute.For <IDateTimeProvider>();
dateTimeProvider.UtcNow().Returns(new DateTime(2019, 03, 10));
_opportunityRepository.GetPipelineOpportunitiesAsync(Arg.Any <int>())
.Returns(new OpportunityReportDtoBuilder()
.AddReferralItem()
.AddProvisionGapItem()
.Build());
var opportunityService = new OpportunityService(mapper, _opportunityRepository, opportunityItemRepository,
provisionGapRepository, referralRepository, googleMapApiClient,
_opportunityPipelineReportWriter, dateTimeProvider);
_result = opportunityService.GetOpportunitySpreadsheetDataAsync(1)
.GetAwaiter().GetResult();
}
public async Task Then_Do_Not_Delete_Opportunity(
[Frozen] IOpportunityRepository opportunityRepo,
[Frozen] IRepository <OpportunityItem> opportunityItemRepo,
[Frozen] IRepository <Domain.Models.Referral> referralRepo,
[Frozen] IRepository <ProvisionGap> provisionGapRepo,
OpportunityItem opportunityItem,
OpportunityService sut)
{
//Arrange
opportunityItem.IsSaved = true;
opportunityItemRepo.GetManyAsync(Arg.Any <Expression <Func <OpportunityItem, bool> > >()).Returns(new List <OpportunityItem>
{
opportunityItem
}.AsQueryable());
referralRepo.GetManyAsync(Arg.Any <Expression <Func <Domain.Models.Referral, bool> > >()).Returns(opportunityItem.Referral.AsQueryable());
provisionGapRepo.GetManyAsync(Arg.Any <Expression <Func <ProvisionGap, bool> > >()).Returns(opportunityItem.ProvisionGap.AsQueryable());
//Act
await sut.DeleteOpportunityItemAsync(opportunityItem.OpportunityId, opportunityItem.OpportunityId);
//Assert
await opportunityRepo.DidNotReceive().DeleteAsync(Arg.Any <int>());
}
public When_OpportunityService_Is_Called_To_Get_Placement_Information_With_Provision_Gap()
{
var config = new MapperConfiguration(c => c.AddMaps(typeof(OpportunityMapper).Assembly));
var mapper = new Mapper(config);
var opportunityRepository = Substitute.For <IOpportunityRepository>();
_opportunityItemRepository = Substitute.For <IRepository <OpportunityItem> >();
var provisionGapRepository = Substitute.For <IRepository <ProvisionGap> >();
var referralRepository = Substitute.For <IRepository <Domain.Models.Referral> >();
var googleMapApiClient = Substitute.For <IGoogleMapApiClient>();
var opportunityPipelineReportWriter = Substitute.For <IFileWriter <OpportunityReportDto> >();
var dateTimeProvider = Substitute.For <IDateTimeProvider>();
var dto = new OpportunityItemBuilder()
.AddProvisionGap()
.AddEmployer()
.Build();
_opportunityItemRepository.GetSingleOrDefaultAsync(Arg.Any <Expression <Func <OpportunityItem, bool> > >(),
Arg.Any <Expression <Func <OpportunityItem, object> > >(),
Arg.Any <Expression <Func <OpportunityItem, object> > >(),
Arg.Any <Expression <Func <OpportunityItem, object> > >())
.Returns(dto);
var opportunityService = new OpportunityService(mapper, opportunityRepository, _opportunityItemRepository,
provisionGapRepository, referralRepository, googleMapApiClient,
opportunityPipelineReportWriter, dateTimeProvider);
_result = opportunityService.GetPlacementInformationAsync(1)
.GetAwaiter().GetResult();
}
public void GetOpportunityByName_Ok()
{
var jsonOpportunity = @"
{
'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': false,
'CareerId': '1',
'ServiceId': '1',
'ProfessionalLevelId': '1',
'OpportunityTypeId': '1',
}";
var opportunity = JsonConvert.DeserializeObject <Opportunity>(jsonOpportunity);
var opportunityName = "Squad Care";
_opportunityRepositoryMock.Setup(x => x.GetOpportunityByName(opportunityName)).Returns(opportunity);
var service = new OpportunityService(_opportunityRepositoryMock.Object);
var result = service.GetOpportunityByName(opportunityName);
Assert.IsNotNull(result);
}
public void InsertOpportunity_Ok()
{
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);
var service = new OpportunityService(_opportunityRepositoryMock.Object);
service.InsertOpportunity(opportunity);
Assert.IsTrue(true);
}
public When_OpportunityService_Is_Called_To_Get_Company_Name_With_Aka_And_Employer_Is_Null()
{
var config = new MapperConfiguration(c => c.AddMaps(typeof(OpportunityMapper).Assembly));
var mapper = new Mapper(config);
_opportunityRepository = Substitute.For <IOpportunityRepository>();
var opportunityItemRepository = Substitute.For <IRepository <OpportunityItem> >();
var provisionGapRepository = Substitute.For <IRepository <ProvisionGap> >();
var referralRepository = Substitute.For <IRepository <Domain.Models.Referral> >();
var googleMapApiClient = Substitute.For <IGoogleMapApiClient>();
var opportunityPipelineReportWriter = Substitute.For <IFileWriter <OpportunityReportDto> >();
var dateTimeProvider = Substitute.For <IDateTimeProvider>();
var opportunity = new Domain.Models.Opportunity
{
Id = 1,
Employer = null
};
_opportunityRepository.GetSingleOrDefaultAsync(Arg.Any <Expression <Func <Domain.Models.Opportunity, bool> > >(),
Arg.Any <Expression <Func <Domain.Models.Opportunity, object> > >())
.Returns(opportunity);
var opportunityService = new OpportunityService(mapper, _opportunityRepository, opportunityItemRepository, provisionGapRepository,
referralRepository, googleMapApiClient,
opportunityPipelineReportWriter, dateTimeProvider);
_result = opportunityService.GetCompanyNameWithAkaAsync(1).GetAwaiter().GetResult();
}
public When_OpportunityService_Is_Called_To_Update_Opportunity_Item()
{
var config = new MapperConfiguration(c => c.AddMaps(typeof(OpportunityMapper).Assembly));
var mapper = new Mapper(config);
var opportunityRepository = Substitute.For <IOpportunityRepository>();
_opportunityItemRepository = Substitute.For <IRepository <OpportunityItem> >();
var provisionGapRepository = Substitute.For <IRepository <ProvisionGap> >();
var referralRepository = Substitute.For <IRepository <Domain.Models.Referral> >();
var googleMapApiClient = Substitute.For <IGoogleMapApiClient>();
var opportunityPipelineReportWriter = Substitute.For <IFileWriter <OpportunityReportDto> >();
var dateTimeProvider = Substitute.For <IDateTimeProvider>();
_opportunityItemRepository
.GetSingleOrDefaultAsync(Arg.Any <Expression <Func <OpportunityItem, bool> > >())
.Returns(new OpportunityItemBuilder().Build());
var opportunityService = new OpportunityService(mapper, opportunityRepository, _opportunityItemRepository, provisionGapRepository,
referralRepository, googleMapApiClient,
opportunityPipelineReportWriter, dateTimeProvider);
var dto = new ProviderSearchDto
{
OpportunityId = OpportunityId,
OpportunityItemId = OpportunityItemId,
RouteId = 1,
SearchRadius = 10,
Postcode = "OX1 1AA"
};
opportunityService.UpdateOpportunityItemAsync(dto).GetAwaiter().GetResult();
}
public void GetAllOpportunities_Ok()
{
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',
}
]";
var listOpporunities = JsonConvert.DeserializeObject <List <Opportunity> >(jsonDataTable);
_opportunityRepositoryMock.Setup(x => x.GetAllOpportunities()).Returns(listOpporunities);
var service = new OpportunityService(_opportunityRepositoryMock.Object);
var result = service.GetAllOpportunities();
Assert.IsNotNull(result);
}
public JsonResult GetOpportunity(Guid opportunityId)
{
var opportunity =
OpportunityService.QueryOpportunity(GetHttpClient(), opportunityId);
return(Json(opportunity, JsonRequestBehavior.AllowGet));
}
public JsonResult ApplyDiscount(Opportunity opportunity, Guid voucherId)
{
var httpClient = GetHttpClient();
var success = OpportunityService.UpdateOpportunity(httpClient, opportunity);
VoucherService.SetVoucherState(GetService(), voucherId);
return(Json(success, JsonRequestBehavior.AllowGet));
}
public When_OpportunityService_Is_Called_To_Update_Referrals()
{
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 <ReferralDto, Domain.Models.Referral>(httpContextAccessor) :
type.Name.Contains("LoggedInUserNameResolver") ?
(object)new LoggedInUserNameResolver <ReferralDto, Domain.Models.Referral>(httpContextAccessor) :
type.Name.Contains("UtcNowResolver") ?
new UtcNowResolver <ReferralDto, Domain.Models.Referral>(new DateTimeProvider()) :
null);
});
var mapper = new Mapper(config);
var opportunityRepository = Substitute.For <IOpportunityRepository>();
var opportunityItemRepository = Substitute.For <IRepository <OpportunityItem> >();
var provisionGapRepository = Substitute.For <IRepository <ProvisionGap> >();
var googleMapApiClient = Substitute.For <IGoogleMapApiClient>();
var opportunityPipelineReportWriter = Substitute.For <IFileWriter <OpportunityReportDto> >();
var dateTimeProvider = Substitute.For <IDateTimeProvider>();
_referralRepository = Substitute.For <IRepository <Domain.Models.Referral> >();
var opportunityService = new OpportunityService(mapper, opportunityRepository, opportunityItemRepository,
provisionGapRepository, _referralRepository, googleMapApiClient,
opportunityPipelineReportWriter, dateTimeProvider);
var dto = new OpportunityItemDto
{
Referral = new List <ReferralDto>
{
new ReferralDto
{
ProviderVenueId = 1,
DistanceFromEmployer = 3.5M
}
}
};
opportunityService.UpdateReferralsAsync(dto).GetAwaiter().GetResult();
}
public CreateOpportunityDialog(StateAccessors accessors, ILoggerFactory loggerFactory,
BotServices botServices, IServiceProvider serviceProvider) : base(nameof(CreateOpportunityDialog))
{
_accessors = accessors;
_loggerFactory = loggerFactory;
_botServices = botServices;
_serviceProvider = serviceProvider;
_leadService = (LeadService)_serviceProvider.GetService(typeof(LeadService));
_opportunityService = (OpportunityService)_serviceProvider.GetService(typeof(OpportunityService));
_productService = (ProductService)_serviceProvider.GetService(typeof(ProductService));
var waterfallSteps = new WaterfallStep[]
{
//Start of dialog
InitializeStateStepAsync,
//Searching for lead
AskForLeadFullNameStepAsync,
SearchLeadStepAsync,
LeadResultHandlerStepAsync,
//Searching for product
AskForProductNameStepAsync,
SearchProductStepAsync,
ProductResultHandlerStepAsync,
//Checking the closing date
AskForClosingDateStepAsync,
SearchClosingDateStepAsync,
ClosingDateResultHandlerStepAsync,
//Checking for comment
AskIfUserWantsToCommentStepAsync,
AskToCommentStepAsync,
FetchingCommentFromUserStepAsync,
//End of Dialog
EndSearchDialogStepAsync
};
var culture = CulturedBot.Culture?.Name;
AddDialog(new WaterfallDialog(_createOpportunityDataWaterfall, waterfallSteps));
//Searching for lead
AddDialog(new TextPrompt(_leadFullNamePrompt));
AddDialog(new TextPrompt(_retryFetchingLeadFromUserPrompt /*, defaultLocale: culture*/));
//Searching for product
AddDialog(new TextPrompt(_productNamePrompt));
AddDialog(new TextPrompt(_retryFetchingProductFromUserPrompt /*, defaultLocale: culture*/));
//Checking the closing date
AddDialog(new TextPrompt(_closingDatePrompt));
AddDialog(new TextPrompt(_retryFetchingClosingDateFromUserPrompt /*, defaultLocale: culture*/));
//Checking for comment
AddDialog(new TextPrompt(_commentPrompt /*, defaultLocale: culture*/));
AddDialog(new TextPrompt(_fetchingCommentFromUserPrompt));
}
public When_OpportunityService_Is_Called_To_Create_Opportunity()
{
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);
_opportunityRepository = Substitute.For <IOpportunityRepository>();
var opportunityItemRepository = Substitute.For <IRepository <OpportunityItem> >();
var provisionGapRepository = Substitute.For <IRepository <ProvisionGap> >();
var referralRepository = Substitute.For <IRepository <Domain.Models.Referral> >();
var googleMapApiClient = Substitute.For <IGoogleMapApiClient>();
var opportunityPipelineReportWriter = Substitute.For <IFileWriter <OpportunityReportDto> >();
var dateTimeProvider = Substitute.For <IDateTimeProvider>();
_opportunityRepository.CreateAsync(Arg.Any <Domain.Models.Opportunity>())
.Returns(OpportunityId);
var opportunityService = new OpportunityService(mapper, _opportunityRepository, opportunityItemRepository,
provisionGapRepository, referralRepository, googleMapApiClient,
opportunityPipelineReportWriter, dateTimeProvider);
var dto = new OpportunityDto
{
EmployerCrmId = new Guid("11111111-1111-1111-1111-111111111111"),
PrimaryContact = "Employer contact",
Email = "*****@*****.**",
Phone = "020 123 4567"
};
_result = opportunityService.CreateOpportunityAsync(dto).GetAwaiter().GetResult();
}
public void DeleteOpportunity_Ok()
{
var jsonOpportunity = @"{
'OpportunityId': 0
}";
var opportunity = JsonConvert.DeserializeObject <Opportunity>(jsonOpportunity);
var service = new OpportunityService(_opportunityRepositoryMock.Object);
service.DeleteOpportunity(opportunity);
Assert.IsTrue(true);
}
public async void TestGetAll()
{
using (var client = server.CreateClient().AcceptJson())
{
var response = await client.GetAsync("/api/Opportunitys");
var result = await response.Content.ReadAsJsonAsync <List <Opportunity> >();
var service = new OpportunityService();
var count = service.GetAll().Count();
Assert.Equal(result.Count, count);
}
}
public async void TestGetById()
{
using (var client = server.CreateClient().AcceptJson())
{
var service = new OpportunityService();
var maxId = service.GetAll().Max(i => i.Id);
var response = await client.GetAsync(string.Format("/api/Opportunitys/{0}", maxId));
var result = await response.Content.ReadAsJsonAsync <Opportunity>();
Assert.Equal(result.Id, maxId);
Assert.Equal((int)response.StatusCode, 200);
}
}
public async Task <ActionResult <Contact_OpportunityDTO> > GetOpportunity([FromBody] Contact_OpportunityDTO Contact_OpportunityDTO)
{
if (UnAuthorization)
{
return(Forbid());
}
if (!ModelState.IsValid)
{
throw new BindException(ModelState);
}
Opportunity Opportunity = await OpportunityService.Get(Contact_OpportunityDTO.Id);
return(new Contact_OpportunityDTO(Opportunity));
}
public When_OpportunityService_Is_Called_To_Clear_Opportunity_Items_Selected_For_Referral()
{
var httpContextAccessor = Substitute.For <IHttpContextAccessor>();
httpContextAccessor.HttpContext.Returns(new DefaultHttpContext
{
User = new ClaimsPrincipal(new ClaimsIdentity(new[]
{
new Claim(ClaimTypes.GivenName, "TestUser")
}))
});
var dateTimeProvider = Substitute.For <IDateTimeProvider>();
dateTimeProvider.UtcNow().Returns(new DateTime(2019, 1, 1));
var config = new MapperConfiguration(c =>
{
c.AddMaps(typeof(OpportunityMapper).Assembly);
c.ConstructServicesUsing(type =>
type.Name.Contains("LoggedInUserEmailResolver") ?
new LoggedInUserEmailResolver <OpportunityItemIsSelectedForReferralDto, OpportunityItem>(httpContextAccessor) :
type.Name.Contains("LoggedInUserNameResolver") ?
(object)new LoggedInUserNameResolver <OpportunityItemIsSelectedForReferralDto, OpportunityItem>(httpContextAccessor) :
type.Name.Contains("UtcNowResolver") ?
new UtcNowResolver <OpportunityItemIsSelectedForReferralDto, OpportunityItem>(dateTimeProvider) :
null);
});
var mapper = new Mapper(config);
var opportunityRepository = Substitute.For <IOpportunityRepository>();
var provisionGapRepository = Substitute.For <IRepository <ProvisionGap> >();
var referralRepository = Substitute.For <IRepository <Domain.Models.Referral> >();
_opportunityItemRepository = Substitute.For <IRepository <OpportunityItem> >();
_opportunityItemRepository
.GetManyAsync(Arg.Any <Expression <Func <OpportunityItem, bool> > >())
.Returns(new OpportunityItemListBuilder().Build().AsQueryable());
var googleMapApiClient = Substitute.For <IGoogleMapApiClient>();
var opportunityPipelineReportWriter = Substitute.For <IFileWriter <OpportunityReportDto> >();
var opportunityService = new OpportunityService(mapper, opportunityRepository, _opportunityItemRepository,
provisionGapRepository, referralRepository, googleMapApiClient,
opportunityPipelineReportWriter, dateTimeProvider);
opportunityService.ClearOpportunityItemsSelectedForReferralAsync(OpportunityId).GetAwaiter().GetResult();
}
