protected override void Setup()
{
Provider provider = new ProviderBuilder()
.WithCode(ProviderCode)
.WithCycle(Context.RecruitmentCycles.Single(rc => rc.Year == RecruitmentCycle.CurrentYear));
Context.Courses.Add(new CourseBuilder()
.WithCode(CourseCode)
.WithProvider(provider)
.WithName(CourseName)
);
_organisation = new Organisation
{
OrganisationUsers = new List <OrganisationUser>
{
new OrganisationUser
{
User = new User
{
Email = Email,
}
}
}
};
provider.OrganisationProviders = new List <OrganisationProvider>
{
new OrganisationProvider
{
Organisation = _organisation
}
};
Context.SaveChanges();
}
public When_MatchingServiceOpportunityReport_Is_Called_For_Pipeline_Opportunity()
{
_dbContext = new TestConfiguration().GetDbContext();
_opportunityBuilder = new OpportunityBuilder(_dbContext);
_providerBuilder = new ProviderBuilder(_dbContext);
_employerBuilder = new EmployerBuilder(_dbContext);
_postcodeLookupBuilder = new PostcodeLookupBuilder(_dbContext);
_localEnterprisePartnershipBuilder = new LocalEnterprisePartnershipBuilder(_dbContext);
ClearData();
var employer = _employerBuilder.CreateEmployer(Guid.NewGuid());
var provider = _providerBuilder.CreateProvider();
_localEnterprisePartnershipBuilder.CreateLocalEnterprisePartnership();
_postcodeLookupBuilder.CreatePostcodeLookup();
_savedReferralOpportunityItem = _opportunityBuilder.CreateReferralOpportunityItem(true, false, provider.ProviderVenue.First().Id);
_savedProvisionGapOpportunityItem = _opportunityBuilder.CreateProvisionGapOpportunityItem(true, false);
_opportunityBuilder.CreateOpportunity(employer.CrmId, new List <OpportunityItem> {
_savedReferralOpportunityItem, _savedProvisionGapOpportunityItem
});
_result = _dbContext.MatchingServiceOpportunityReport.ToList();
}
public When_MatchingServiceProviderOpportunityReport_Is_Called_For_Multiple_Opportunity_And_Single_Provider_Venue()
{
_dbContext = new TestConfiguration().GetDbContext();
_opportunityBuilder = new OpportunityBuilder(_dbContext);
_providerBuilder = new ProviderBuilder(_dbContext);
_employerBuilder = new EmployerBuilder(_dbContext);
_postcodeLookupBuilder = new PostcodeLookupBuilder(_dbContext);
_localEnterprisePartnershipBuilder = new LocalEnterprisePartnershipBuilder(_dbContext);
ClearData();
var employer = _employerBuilder.CreateEmployer(Guid.NewGuid());
_provider = _providerBuilder.CreateProvider();
_localEnterprisePartnershipBuilder.CreateLocalEnterprisePartnership();
_postcodeLookupBuilder.CreatePostcodeLookup();
var savedReferralOpportunityItem1 = _opportunityBuilder.CreateReferralOpportunityItem(true, true, _provider.ProviderVenue.Select(pv => pv.Id).ToArray());
var savedReferralOpportunityItem2 = _opportunityBuilder.CreateReferralOpportunityItem(true, true, _provider.ProviderVenue.Select(pv => pv.Id).ToArray());
_opportunityBuilder.CreateOpportunity(employer.CrmId, new List <OpportunityItem> {
savedReferralOpportunityItem1, savedReferralOpportunityItem2
});
_result = _dbContext.MatchingServiceProviderOpportunityReport.ToList();
}
protected override void When()
{
var builder = new ProviderBuilder(_definition.Source.Providers);
var providerOperation = new BasicProviderOperation <TBuilder>(_definition, _webDeployer, _providerAction);
_provider = (TProvider)_definition.Source.Providers[0];
}
public ProviderBuilder AddProvider(string name)
{
var rv = new ProviderBuilder(name);
this.Providers.Add(rv);
return(rv);
}
public When_MatchingServiceOpportunityReport_Is_Called_For_Saved_OpportunityOpportunities()
{
_dbContext = new TestConfiguration().GetDbContext();
_opportunityBuilder = new OpportunityBuilder(_dbContext);
_providerBuilder = new ProviderBuilder(_dbContext);
_employerBuilder = new EmployerBuilder(_dbContext);
ClearData();
var employer = _employerBuilder.CreateEmployer(Guid.NewGuid());
var provider1 = _providerBuilder.CreateProvider();
var provider2 = _providerBuilder.CreateProvider();
_savedReferralOpportunityItem = _opportunityBuilder.CreateReferralOpportunityItem(true, true, provider1.ProviderVenue.First().Id);
_savedProvisionGapOpportunityItem = _opportunityBuilder.CreateProvisionGapOpportunityItem(true, true);
_unsavedReferralOpportunityItem = _opportunityBuilder.CreateReferralOpportunityItem(false, false, provider2.ProviderVenue.First().Id);
_unsavedProvisionGapOpportunityItem = _opportunityBuilder.CreateProvisionGapOpportunityItem(false, false);
_opportunityBuilder.CreateOpportunity(employer.CrmId, new List <OpportunityItem> {
_savedReferralOpportunityItem, _savedProvisionGapOpportunityItem, _unsavedReferralOpportunityItem, _unsavedProvisionGapOpportunityItem
});
_result = _dbContext.MatchingServiceOpportunityReport.ToList();
}
protected Provider NewProvider(Action <ProviderBuilder> setUp = null)
{
ProviderBuilder providerBuilder = new ProviderBuilder();
setUp?.Invoke(providerBuilder);
return(providerBuilder.Build());
}
private static Provider NewProvider(Action <ProviderBuilder> setUp = null)
{
ProviderBuilder providerBuilder = new ProviderBuilder();
setUp?.Invoke(providerBuilder);
return(providerBuilder.Build());
}
private static Provider ProviderCopy(Provider provider, Action <Provider> differences = null)
{
Provider copy = new ProviderBuilder()
.WithPropertiesFrom(provider)
.Build();
differences?.Invoke(copy);
return(copy);
}
public static IServiceCollection AddSportLevelRunTime(
this IServiceCollection services,
Action <IProviderBuilder> configureDelegate
)
{
IProviderBuilder builder = new ProviderBuilder(services);
configureDelegate.Invoke(builder);
return(services);
}
/// <summary>
/// Main entry point
/// </summary>
/// <param name="args">Command line arguments passed in</param>
/// <returns>Empty Task that completes when the application has finished</returns>
/// <exception cref="ArgumentException">Exception thrown when the program was called with invalid argumente</exception>
static void Main(string[] args)
{
ProviderBuilder builder = new ProviderBuilder();
IServiceProvider container = builder.AutowireAssembly(Assembly.GetExecutingAssembly()).Build();
Arguments arguments = new Arguments(args);
if (!arguments.HasArgument("p"))
{
throw new ArgumentException("No problem specified with argument p");
}
Program.Autorun(container, arguments);
}
/// <summary>
/// Name: ConfigureOAuth
/// Description: Metho to define the configuration of OAuth
/// </summary>
/// <param name="app">IAppBuilder</param>
public void ConfigureOAuth(IAppBuilder app)
{
ProviderBuilder providerBuilder = ProviderBuilder.GetInstance();
IOAuthAuthorizationServerProvider provider = providerBuilder.GetProvider <IOAuthAuthorizationServerProvider>(ProviderBuilder.IAUTHAUTHORIZATIONSERVERPROVIDER);
IAuthenticationTokenProvider tokenProvider = providerBuilder.GetProvider <IAuthenticationTokenProvider>(ProviderBuilder.IAUTHENTICATIONTOKENPROVIDER);
OAuthAuthorizationServerOptions OAuthServerOptions = new OAuthAuthorizationServerOptions()
{
AllowInsecureHttp = true,
TokenEndpointPath = new PathString("/token"),
AccessTokenExpireTimeSpan = TimeSpan.FromMinutes(120),
Provider = provider,
RefreshTokenProvider = tokenProvider
};
app.UseOAuthAuthorizationServer(OAuthServerOptions);
app.UseOAuthBearerAuthentication(new OAuthBearerAuthenticationOptions());
}
///////////////////////////////////////////
// Target Requests
#if LATER
public int RequestTarget(string name)
{
int i = name.LastIndexOf('/');
string basename = name.Substring(i + 1);
string basis = name.Substring(0, i + 1); // include trailing slash
ProviderBuilder pb = GetProvider(basis);
TargetBuilder tb = pb.GetTarget(basename);
if (tb == null)
{
tb = pb.RequestTarget(basename);
}
else
{
return(((WrenchTarget)tb).Id);
}
}
public Provider ToSDKProvider()
{
if (sdkProvider != null)
{
return(sdkProvider);
}
else if (apiProvider != null)
{
ProviderBuilder builder = ProviderBuilder.NewProvider(apiProvider.Name)
.WithId(apiProvider.Id)
.WithProvides(apiProvider.Provides)
.WithData(apiProvider.Data);
return(builder.Build());
}
else
{
return(null);
}
}
private void AddRolloverData()
{
// add a provider/course in the next cycle to make sure we're getting the right one
Provider provider2020 = new ProviderBuilder()
.WithCode(ProviderCode)
.WithCycle(Context.RecruitmentCycles.Single(rc => rc.Year == Year2020));
Context.Courses.Add(new CourseBuilder()
.WithCode(CourseCode)
.WithProvider(provider2020)
.WithName(CourseName + " 2020")
);
_organisation.OrganisationProviders.Add(
new OrganisationProvider
{
Provider = provider2020
});
Context.SaveChanges();
Context.Courses.Count().Should().Be(2);
}
public When_MatchingServiceProviderOpportunityReport_Is_Called_For_Single_Provider_Multiple_Venues()
{
_dbContext = new TestConfiguration().GetDbContext();
_opportunityBuilder = new OpportunityBuilder(_dbContext);
_providerBuilder = new ProviderBuilder(_dbContext);
_employerBuilder = new EmployerBuilder(_dbContext);
ClearData();
var employer = _employerBuilder.CreateEmployer(Guid.NewGuid());
var provider = _providerBuilder.CreateProvider(2);
_savedReferralOpportunityItem = _opportunityBuilder.CreateReferralOpportunityItem(true, true, provider.ProviderVenue.Select(pv => pv.Id).ToArray());
_opportunityBuilder.CreateOpportunity(employer.CrmId, new List <OpportunityItem> {
_savedReferralOpportunityItem
});
_result = _dbContext.MatchingServiceProviderOpportunityReport.ToList();
}
public async Task ThenTheProviderIsSaved()
{
var expectedProvider = new ProviderBuilder().Build();
_roatpGateway.Setup(x => x.GetProvider(expectedProvider.Ukprn.ToString())).Returns(expectedProvider);
var evt = new AgreementEventView()
{
ContractType = "ProviderAgreement",
Event = "INITIATED",
CreatedOn = DateTime.Now.AddDays(-1),
Id = 3,
ProviderId = "12345678"
};
await _commandHandler.Handle(new CreateProviderCommand()
{
Event = evt
});
_providerRepository.Verify(x => x.SaveProvider(expectedProvider), Times.Once);
}
public void BuildProvider()
{
var comp1 = new ComputerBuilder()
.SetName("1")
.AddService(new Service("a", ServicesManager.Services.ServiceState.Running))
.Build();
var comp2 = new ComputerBuilder()
.SetName("2")
.AddService(new Service("b", ServicesManager.Services.ServiceState.Stopped))
.Build();
var provider = new ProviderBuilder().AddComputer(comp1).AddComputer(comp2).Build();
var actual = provider.EnumerateComputers().ToHashSet();
var expected = new HashSet <IComputer>()
{
comp1,
comp2
};
Assert.Equal(expected, actual);
}
public async Task CourseDirectoryImportFunction_GetProviders_Returns_Expected_Result()
{
var builder = new ProviderBuilder();
var providers = builder.BuildList();
var expectedResult = builder.BuildJson().PrettifyJsonString();
var tableStorageService = Substitute.For <ITableStorageService>();
tableStorageService.GetAllProviders().Returns(providers);
var functionContext = FunctionObjectsBuilder.BuildFunctionContext();
var request = FunctionObjectsBuilder.BuildHttpRequestData(HttpMethod.Get);
var functions = BuildCourseDirectoryImportFunctions(tableStorageService: tableStorageService);
var result = await functions.GetProviders(request, functionContext);
result.Headers.GetValues("Content-Type").Should().NotBeNull();
result.Headers.GetValues("Content-Type").First().Should().Be("application/json");
var json = await result.Body.ReadAsString();
json.PrettifyJsonString().Should().Be(expectedResult);
}
public Provider(ProviderBuilder builder)
{
Name = builder.Name;
ContactId = builder.ContactId;
Contact = builder.Contact;
}
public void AllVariations()
{
// build a big payload with all of the above
const string instCode = "AA1";
const string instCodeOptedIn = "AA2";
const string instName = "Armadillo 1";
const string modifiedInstName = "Modified " + instName;
const string instNameOptedIn = "OptedIn Armadillo 2";
const string accreditingProviderCode = "AINST201";
const string accreditingProviderCodeOptedIn = "AINST202";
const string accreditingProviderCode3 = "AINST203";
const string accreditingProviderCode4 = "AINST204";
const string courseCode = "CRS101";
const string courseCode2 = "CRS102";
const string courseCode3 = "CRS103";
const string unmodifiedCourseName = "Primary";
const string modifiedCourseName = "Modified " + unmodifiedCourseName;
const string campusCode = "CAMP101";
// arrange
// accrediting providers
var accreditingProvider = new ProviderBuilder()
.WithCode(accreditingProviderCode);
Context.Providers.Add(accreditingProvider);
var accreditingProviderOptedIn = new ProviderBuilder()
.WithOptedIn()
.WithCode(accreditingProviderCodeOptedIn);
Context.Providers.Add(accreditingProviderOptedIn);
Context.Providers.Add(new ProviderBuilder()
.WithCode(accreditingProviderCode3));
Context.Providers.Add(new ProviderBuilder()
.WithCode(accreditingProviderCode4));
// non-opted in provider and its courses
Context.Providers.Add(new ProviderBuilder()
.WithCode(instCode)
.WithName(instName)
.WithCourses(new List <Course>
{
new CourseBuilder()
.WithCode(courseCode)
.WithName(unmodifiedCourseName),
new CourseBuilder()
.WithCode(courseCode2)
.WithAccreditingProvider(accreditingProvider),
new CourseBuilder()
.WithCode(courseCode3)
.WithAccreditingProvider(accreditingProviderOptedIn),
}));
// opted in provider and its courses
Context.Providers.Add(new ProviderBuilder()
.WithCode(instCodeOptedIn)
.WithName(instNameOptedIn)
.WithOptedIn()
.WithCourses(new List <Course>
{
new CourseBuilder()
.WithCode(courseCode)
.WithName(unmodifiedCourseName),
new CourseBuilder()
.WithCode(courseCode2)
.WithAccreditingProvider(accreditingProvider),
new CourseBuilder()
.WithCode(courseCode3)
.WithAccreditingProvider(accreditingProviderOptedIn),
}));
Context.Save();
var ucasPayload = new PayloadBuilder()
.WithInstitutions(new List <UcasInstitution>
{
new PayloadInstitutionBuilder()
.WithFullName(modifiedInstName)
.WithInstCode(instCode),
new PayloadInstitutionBuilder()
.WithFullName("Modified " + instNameOptedIn)
.WithInstCode(instCodeOptedIn),
})
.WithCourses(new List <UcasCourse> {
new PayloadCourseBuilder()
.WithInstCode(instCode)
.WithCrseCode(courseCode)
.WithName(modifiedCourseName)
.WithCampusCode(campusCode),
new PayloadCourseBuilder()
.WithInstCode(instCode)
.WithCrseCode(courseCode2)
.WithAccreditingProvider(accreditingProviderCode3)
.WithCampusCode(campusCode),
new PayloadCourseBuilder()
.WithInstCode(instCode)
.WithCrseCode(courseCode3)
.WithAccreditingProvider(accreditingProviderCode4)
.WithCampusCode(campusCode),
new PayloadCourseBuilder()
.WithInstCode(instCodeOptedIn)
.WithCrseCode(courseCode)
.WithName(modifiedCourseName)
.WithCampusCode(campusCode),
new PayloadCourseBuilder()
.WithInstCode(instCodeOptedIn)
.WithCrseCode(courseCode2)
.WithAccreditingProvider(accreditingProviderCode3)
.WithCampusCode(campusCode),
new PayloadCourseBuilder()
.WithInstCode(instCodeOptedIn)
.WithCrseCode(courseCode3)
.WithAccreditingProvider(accreditingProviderCode4)
.WithCampusCode(campusCode),
})
.WithCampuses(new List <UcasCampus>
{
new PayloadCampusBuilder()
.WithCampusCode(campusCode)
.WithInstCode(instCode)
});
// act
DoImport(ucasPayload);
// assert
var provider = Context.Providers.Single(p => p.ProviderCode == instCode);
provider.ProviderName.Should().Be(modifiedInstName);
provider.Courses.Count(c => c.Provider.ProviderCode == instCode).Should().Be(3);
provider.Courses.Single(c => c.Provider.ProviderCode == instCode && c.CourseCode == courseCode)
.Name.Should().Be(modifiedCourseName);
provider.Courses.Single(c => c.Provider.ProviderCode == instCode && c.CourseCode == courseCode2)
.AccreditingProvider.ProviderCode.Should().Be(accreditingProviderCode3);
provider.Courses.Single(c => c.Provider.ProviderCode == instCode && c.CourseCode == courseCode3)
.AccreditingProvider.ProviderCode.Should().Be(accreditingProviderCode4);
}
public void withSpecifiedValues()
{
AccountBuilder accountBuilder = AccountBuilder.NewAccount()
.WithName(ACC_NAME)
.WithId(ACC_ID)
.WithOwner(ACC_OWNER)
.WithLogoUrl(ACC_LOGOURL)
.WithData(ACC_DATA)
.WithCompany(CompanyBuilder.NewCompany(ACC_CO_NAME)
.WithAddress(AddressBuilder.NewAddress()
.WithAddress1(ACC_CO_ADDR_ADDR1)
.WithAddress2(ACC_CO_ADDR_ADDR2)
.WithCity(ACC_CO_ADDR_CITY)
.WithCountry(ACC_CO_ADDR_COUNTRY)
.WithState(ACC_CO_ADDR_STATE)
.WithZipCode(ACC_CO_ADDR_ZIP).Build())
.WithId(ACC_CO_ID)
.WithData(ACC_CO_DATA)
.Build())
.WithCustomField(CustomFieldBuilder.CustomFieldWithId(ACC_FIELD_ID)
.WithDefaultValue(ACC_FIELD_DEF_VLE)
.IsRequired(ACC_FIELD_IS_REQUIRED)
.WithTranslation(TranslationBuilder.NewTranslation(ACC_FIELD_TRANSL_LANG).Build())
.Build())
.WithLicense(LicenseBuilder.NewLicense()
.CreatedOn(ACC_LIC_CREATED)
.WithPaidUntil(ACC_LIC_PAIDUNTIL)
.WithStatus(ACC_LIC_STATUS)
.WithTransaction(ACC_LIC_TRANS_CREATED,
CreditCardBuilder.NewCreditCard()
.WithCvv(ACC_LIC_TRANS_CC_CVV)
.WithName(ACC_LIC_TRANS_CC_NAME)
.WithNumber(ACC_LIC_TRANS_CC_NUM)
.WithType(ACC_LIC_TRANS_CC_TYPE)
.WithExpiration(ACC_LIC_TRANS_CC_EXP_MONTH, ACC_LIC_TRANS_CC_EXP_YEAR)
.Build(),
PriceBuilder.NewPrice()
.WithAmount(ACC_LIC_TRANS_PRICE_AMOUNT)
.WithCurrency(ACC_LIC_TRANS_PRICE_CURR_ID, ACC_LIC_TRANS_PRICE_CURR_NAME,
ACC_LIC_TRANS_PRICE_CURR_DATA)
.Build())
.WithPlan(PlanBuilder.NewPlan(ACC_LIC_PLAN_ID)
.WithId(ACC_LIC_PLAN_NAME)
.WithContract(ACC_LIC_PLAN_CONTRACT)
.WithDescription(ACC_LIC_PLAN_DES)
.WithGroup(ACC_LIC_PLAN_GRP)
.WithCycle(ACC_LIC_PLAN_CYC)
.WithOriginal(ACC_LIC_PLAN_ORI)
.WithData(ACC_LIC_PLAN_DATA)
.WithFreeCycles(ACC_LIC_PLAN_CYC_COUNT, ACC_LIC_PLAN_CYC_CYCLE)
.WithQuota(ACC_LIC_PLAN_QUOTA_CYCLE, ACC_LIC_PLAN_QUOTA_LIMIT, ACC_LIC_PLAN_QUOTA_SCOPE,
ACC_LIC_PLAN_QUOTA_TARGET)
.WithFeatures(ACC_LIC_PLAN_FEAT)
.WithPrice(PriceBuilder.NewPrice()
.WithAmount(ACC_LIC_PLAN_PRICE_AMOUNT)
.WithCurrency(ACC_LIC_PLAN_PRICE_CURR_ID, ACC_LIC_PLAN_PRICE_CURR_NAME,
ACC_LIC_PLAN_PRICE_CURR_DATA)
.Build())
.Build())
.Build())
.WithAccountProviders(new List <Provider>()
{
ProviderBuilder.NewProvider(ACC_PROV_DOC_NAME)
.WithData(ACC_PROV_DOC_DATA)
.WithId(ACC_PROV_DOC_ID)
.WithProvides(ACC_PROV_DOC_NAME)
.Build()
}, new List <Provider>()
{
ProviderBuilder.NewProvider(ACC_PROV_USR_NAME)
.WithData(ACC_PROV_USR_DATA)
.WithId(ACC_PROV_USR_ID)
.WithProvides(ACC_PROV_USR_PROVIDES)
.Build()
});
Account account = accountBuilder.Build();
Assert.AreEqual(ACC_NAME, account.Name);
Assert.AreEqual(ACC_CO_ID, account.Company.Id);
Assert.AreEqual(ACC_CO_ADDR_ADDR1, account.Company.Address.Address1);
Assert.AreEqual(1, account.CustomFields.Count);
Assert.AreEqual(ACC_FIELD_DEF_VLE, account.CustomFields[0].Value);
Assert.AreEqual(1, account.CustomFields[0].Translations.Count);
Assert.AreEqual(ACC_FIELD_TRANSL_LANG, account.CustomFields[0].Translations[0].Language);
Assert.AreEqual(1, account.Licenses.Count);
Assert.AreEqual(ACC_LIC_STATUS, account.Licenses[0].Status);
Assert.AreEqual(1, account.Licenses[0].Transactions.Count);
Assert.AreEqual(ACC_LIC_TRANS_CC_NUM, account.Licenses[0].Transactions[0].CreditCard.Number);
Assert.AreEqual(ACC_LIC_TRANS_PRICE_AMOUNT, account.Licenses[0].Transactions[0].Price.Amount);
Assert.AreEqual(ACC_LIC_PLAN_CONTRACT, account.Licenses[0].Plan.Contract);
Assert.AreEqual(ACC_LIC_PLAN_PRICE_AMOUNT, account.Licenses[0].Plan.Price.Amount);
Assert.AreEqual(1, account.Providers.Documents.Count);
Assert.AreEqual(ACC_PROV_DOC_NAME, account.Providers.Documents[0].Name);
Assert.AreEqual(1, account.Providers.Users.Count);
Assert.AreEqual(ACC_PROV_USR_NAME, account.Providers.Users[0].Name);
}
public BuildfileLoader(string buildfile, ProviderBuilder pb, IWarningLogger log)
{
parser = BuildfileParser.CreateForFile(buildfile, pb, log);
// Console.WriteLine ("Parsing `{0}\' ... ", buildfile);
errors = parser.Parse();
}
private void ConfigureAgreementsApi()
{
var provider = new ProviderBuilder().Build();
EventsApi.SetupGet("api/providers/12345678", provider);
}
