it(`${scenario.name}`, async () => {
switch (scenario.id) {
case 'nothing_space':
// Saved Objects Managment is not available when everything is disabled.
const nothingSpaceCapabilities = await uiCapabilitiesService.get({
spaceId: scenario.id,
});
expect(nothingSpaceCapabilities.success).to.be(true);
expect(nothingSpaceCapabilities.value).to.have.property('savedObjectsManagement');
const nothingSpaceExpected = mapValues(
nothingSpaceCapabilities.value!.savedObjectsManagement,
() => savedObjectsManagementBuilder.uiCapabilities('none')
);
expect(nothingSpaceCapabilities.value!.savedObjectsManagement).to.eql(
nothingSpaceExpected
);
break;
default:
// Otherwise it's available without restriction
const uiCapabilities = await uiCapabilitiesService.get({ spaceId: scenario.id });
expect(uiCapabilities.success).to.be(true);
expect(uiCapabilities.value).to.have.property('savedObjectsManagement');
const expected = mapValues(uiCapabilities.value!.savedObjectsManagement, () =>
savedObjectsManagementBuilder.uiCapabilities('all')
);
expect(uiCapabilities.value!.savedObjectsManagement).to.eql(expected);
}
});
it(`${scenario.name}`, async () => {
const uiCapabilities = await uiCapabilitiesService.get({ spaceId: scenario.id });
switch (scenario.id) {
case 'everything_space': {
expect(uiCapabilities.success).to.be(true);
expect(uiCapabilities.value).to.have.property('catalogue');
// everything is enabled
const expected = mapValues(uiCapabilities.value!.catalogue, () => true);
expect(uiCapabilities.value!.catalogue).to.eql(expected);
break;
}
case 'nothing_space': {
expect(uiCapabilities.success).to.be(true);
expect(uiCapabilities.value).to.have.property('catalogue');
// everything is disabled
const expected = mapValues(uiCapabilities.value!.catalogue, () => false);
expect(uiCapabilities.value!.catalogue).to.eql(expected);
break;
}
case 'foo_disabled_space': {
expect(uiCapabilities.success).to.be(true);
expect(uiCapabilities.value).to.have.property('catalogue');
// only foo is disabled
const expected = mapValues(
uiCapabilities.value!.catalogue,
(value, catalogueId) => catalogueId !== 'foo'
);
expect(uiCapabilities.value!.catalogue).to.eql(expected);
break;
}
default:
throw new UnreachableError(scenario);
}
});
export async function getAllOutcomesProfitLoss(db: Knex, params: GetProfitLossParamsType): Promise<AllOutcomesProfitLoss> {
const { profits, outcomeValues, buckets, lastTradePriceMinusMinPrice24hAgoByOutcomeByMarketId, oldestTradePriceMinusMinPriceUserPaidForOpenPositionInLast24hByOutcomeByMarketId } = await getProfitLossData(db, params);
const bucketedProfits = _.mapValues(profits, (pls, marketId) => {
return bucketAtTimestamps<ProfitLossTimeseries>(pls, buckets, Object.assign(getDefaultPLTimeseries(), { marketId }));
});
const bucketedOutcomeValues = _.mapValues(outcomeValues, (marketOutcomeValues) => {
return bucketAtTimestamps<OutcomeValueTimeseries>(marketOutcomeValues, buckets, getDefaultOVTimeseries());
});
const profit = _.mapValues(bucketedProfits, (pls, marketId) => {
return getProfitResultsForMarket(pls, bucketedOutcomeValues[marketId], buckets, lastTradePriceMinusMinPrice24hAgoByOutcomeByMarketId, oldestTradePriceMinusMinPriceUserPaidForOpenPositionInLast24hByOutcomeByMarketId);
});
const marketOutcomes = _.fromPairs(_.values(_.mapValues(profits, (pls) => {
const first = _.first(_.first(_.values(pls)))!;
return [first.marketId, first.numOutcomes];
})));
return {
profit,
marketOutcomes,
buckets,
};
}
async run(input: Input) {
this.logger.info(`Collating venues for ${this.academicYear} semester ${this.semester}`);
// Insert module code and flatten lessons
const venueLessons: LessonWithModuleCode[] = flatMap(input, (module) =>
module.semesterData.timetable.map(
(lesson: RawLesson): LessonWithModuleCode => ({
...lesson,
moduleCode: module.moduleCode,
}),
),
);
const venues = extractVenueAvailability(venueLessons);
// Get a mapping of module code to module title to help with module aliasing
const moduleCodeToTitle: { [moduleCode: string]: ModuleTitle } = {};
input.forEach((module) => {
moduleCodeToTitle[module.moduleCode] = module.module.title;
});
// Merge dual-coded modules and extract the aliases generated for use later
const allAliases: ModuleAliases = {};
for (const venue of values(venues)) {
for (const availability of venue) {
const { lessons, aliases } = mergeDualCodedModules(availability.classes);
availability.classes = lessons;
// Merge the alias mappings
for (const [moduleCode, alias] of entries(aliases)) {
// Only add the modules as alias if they have the same title
const title = moduleCodeToTitle[moduleCode];
const filteredAliases = Array.from(alias).filter(
(module) => title === moduleCodeToTitle[module],
);
if (filteredAliases.length) {
allAliases[moduleCode] = union(
allAliases[moduleCode] || new Set(),
new Set(filteredAliases),
);
}
}
}
}
// Save the results
const outputAliases = mapValues(allAliases, (moduleCodes) => Array.from(moduleCodes));
const venueList = Object.keys(venues);
await Promise.all([
this.io.venueInformation(this.semester, venues),
this.io.venueList(this.semester, venueList),
this.aliasCache.write(mapValues(outputAliases, (set): string[] => Array.from(set))),
]);
return { venues, aliases: allAliases };
}
it('undefined nested values in new settings should be ignored', () => {
const newSettings: SettingsPartial<any> = {
filterOptions: _.mapValues(allSettings.filterOptions, _.constant(undefined)),
dataOptions: _.mapValues(allSettings.dataOptions, _.constant(undefined)),
groupOptions: _.mapValues(allSettings.groupOptions, _.constant(undefined))
};
const actual = Settings.merge(allSettings, newSettings);
expect(actual).toEqualPlainObject(allSettings);
});
function getRefPaths(obj: object, paths: { [key: string]: any }): { [key: string]: string } {
// pick because it's an object (map)
const singleRefsFiltered = pickBy(paths, schemaType => schemaType.options && schemaType.options.ref);
const singleRefs = mapValues(singleRefsFiltered, schemaType => schemaType.options.ref);
const arrayRefsFiltered = pickBy(paths, schemaType => schemaType.caster && schemaType.caster.instance && schemaType.caster.options && schemaType.caster.options.ref);
const arrayRefs = mapValues(arrayRefsFiltered, schemaType => schemaType.caster.options.ref);
return explodePaths(obj, singleRefs, arrayRefs);
}
it(`${scenario.fullName}`, async () => {
const uiCapabilities = await uiCapabilitiesService.get({
credentials: {
username: scenario.username,
password: scenario.password,
},
});
switch (scenario.username) {
case 'superuser': {
expect(uiCapabilities.success).to.be(true);
expect(uiCapabilities.value).to.have.property('catalogue');
// everything is enabled
const expected = mapValues(uiCapabilities.value!.catalogue, () => true);
expect(uiCapabilities.value!.catalogue).to.eql(expected);
break;
}
case 'all':
case 'read':
case 'dual_privileges_all':
case 'dual_privileges_read': {
expect(uiCapabilities.success).to.be(true);
expect(uiCapabilities.value).to.have.property('catalogue');
// everything except ml and monitoring is enabled
const expected = mapValues(
uiCapabilities.value!.catalogue,
(enabled, catalogueId) => catalogueId !== 'ml' && catalogueId !== 'monitoring'
);
expect(uiCapabilities.value!.catalogue).to.eql(expected);
break;
}
case 'foo_all':
case 'foo_read': {
expect(uiCapabilities.success).to.be(true);
expect(uiCapabilities.value).to.have.property('catalogue');
// only foo is enabled
const expected = mapValues(
uiCapabilities.value!.catalogue,
(value, catalogueId) => catalogueId === 'foo'
);
expect(uiCapabilities.value!.catalogue).to.eql(expected);
break;
}
// these users have no access to even get the ui capabilities
case 'legacy_all':
case 'no_kibana_privileges':
expect(uiCapabilities.success).to.be(false);
expect(uiCapabilities.failureReason).to.be(GetUICapabilitiesFailureReason.NotFound);
break;
default:
throw new UnreachableError(scenario);
}
});
it(`${scenario.fullName}`, async () => {
const uiCapabilities = await uiCapabilitiesService.get({
credentials: {
username: scenario.username,
password: scenario.password,
},
});
switch (scenario.username) {
case 'superuser':
case 'all':
case 'dual_privileges_all':
expect(uiCapabilities.success).to.be(true);
expect(uiCapabilities.value).to.have.property('savedObjectsManagement');
const expected = mapValues(uiCapabilities.value!.savedObjectsManagement, () =>
savedObjectsManagementBuilder.uiCapabilities('all')
);
expect(uiCapabilities.value!.savedObjectsManagement).to.eql(expected);
break;
case 'read':
case 'dual_privileges_read':
expect(uiCapabilities.success).to.be(true);
expect(uiCapabilities.value).to.have.property('savedObjectsManagement');
const expectedRead = mapValues(uiCapabilities.value!.savedObjectsManagement, () =>
savedObjectsManagementBuilder.uiCapabilities('read')
);
expect(uiCapabilities.value!.savedObjectsManagement).to.eql(expectedRead);
break;
case 'foo_all':
case 'foo_read':
expect(uiCapabilities.success).to.be(true);
expect(uiCapabilities.value).to.have.property('savedObjectsManagement');
expect(uiCapabilities.value!.savedObjectsManagement).to.eql(
savedObjectsManagementBuilder.build({
all: [],
read: [],
})
);
break;
case 'no_kibana_privileges':
// these users have no access to any ui capabilities
case 'legacy_all':
case 'no_kibana_privileges':
expect(uiCapabilities.success).to.be(false);
expect(uiCapabilities.failureReason).to.be(GetUICapabilitiesFailureReason.NotFound);
break;
default:
throw new UnreachableError(scenario);
}
});
export function locatonExtractor(text: string): any {
const allPhrases = createTokens(text);
// console.log('allPhrases', allPhrases);
const matchingCities = _.mapValues(locations, topic =>
_.pickBy(topic, (value: Array<string>, key: string) => {
const theseCities = value.map(location => location.toLowerCase());
// console.log(theseCities);
return _.intersection(allPhrases, theseCities).length > 0;
}));
// console.log('matchingCities', matchingCities);
const pickedTopics = _.pickBy(matchingCities, topic => _.keys(topic).length > 0);
const mapped = _.mapValues(pickedTopics, topic => _.keys(topic));
// console.log(matchingCities);
return mapped as locationMap;
}
async function fetch(
queries:IQuery[],
sampleFilterByProfile: SampleFilterByProfile
): Promise<AugmentedData<GenesetMolecularData[], IQuery>[]> {
const genesetIdsByProfile = _.mapValues(
_.groupBy(queries, q => q.molecularProfileId),
profileQueries => profileQueries.map(q => q.genesetId)
);
const params = Object.keys(genesetIdsByProfile)
.map(profileId => ({
geneticProfileId: profileId,
// the Swagger-generated type expected by the client method below
// incorrectly requires both samples and a sample list;
// use 'as' to tell TypeScript that this object really does fit.
// tslint:disable-next-line: no-object-literal-type-assertion
genesetDataFilterCriteria: {
genesetIds: genesetIdsByProfile[profileId],
...sampleFilterByProfile[profileId]
} as GenesetDataFilterCriteria
})
);
const dataPromises = params.map(param => client.fetchGeneticDataItemsUsingPOST(param));
const results: GenesetMolecularData[][] = await Promise.all(dataPromises);
return augmentQueryResults(queries, results);
}
