Secure your code as it's written. Use Snyk Code to scan source code in minutes - no build needed - and fix issues immediately.
switch (column.aggregate) {
case AggregateFunctions.Sum:
value = _.sumBy(subset, column.name);
break;
case AggregateFunctions.Average:
value = _.meanBy(subset, column.name);
break;
case AggregateFunctions.Max:
// .maxBy returns the object containing the max value
value = _.maxBy(subset, column.name)[column.name];
break;
case AggregateFunctions.Min:
// .minBy returns the object containing the min value
value = _.minBy(subset, column.name)[column.name];
break;
case AggregateFunctions.Count:
value = subset.length;
break;
case AggregateFunctions.DistinctCount:
value = _.uniqWith(subset, (a, b) => {
return a[column.name] == b[column.name];
}).length;
break;
default:
throw 'Unsupported aggregate function';
}
return { [column.name]: value };
});
it("uses Count", done => {
const take = 10,
filteredCount = totalRecordCount;
let request = new GridRequest(
[
{
name: 'first_name', label: 'First Name', sortable: true, searchable: true, aggregate: AggregateFunctions.Count
},
{
name: 'last_name', label: 'Last Name', sortable: true, searchable: true
},
{
name: 'address_id', label: 'Address Id', sortable: true, searchable: false
}
],
take,
0,
);
let queryBuilder = knex.select('first_name', 'last_name', 'address_id').from('customer');
tubular.createGridResponse(request, queryBuilder)
.then(response => {
let request = new GridRequest(
[
{
name: 'customer_id', label: 'Customer Id', sortable: true, searchable: true, filter: {
name: '',
text: 1,
argument: [],
operator: CompareOperators.Equals,
hasFilter: false
}
},
{
name: 'amount', label: 'Amount', sortable: true, searchable: true, aggregate: AggregateFunctions.Sum
},
{
name: 'payment_id', label: 'Payment Id', sortable: true, searchable: false, aggregate: AggregateFunctions.Count
}
],
take,
0,
);
tubular.createGridResponse(request, queryBuilder)
.then(response => {
expect(response.counter).toBeDefined();
expect(response.totalRecordCount).toBe(totalRecordCount);
expect(response.filteredRecordCount).toBe(filteredCount);
expect(response.totalPages).toBe(Math.ceil(filteredCount / take));
expect(response.payload.length).toBe(take);
expect(response.aggregationPayload).toBeDefined();
expect(response.aggregationPayload.amount).toBeGreaterThan(0);
copyOfSubset.clearSelect();
switch (column.aggregate) {
case AggregateFunctions.Sum:
copyOfSubset = copyOfSubset.sum(`${column.name} as tbResult`);
break;
case AggregateFunctions.Average:
copyOfSubset = copyOfSubset.avg(`${column.name} as tbResult`);
break;
case AggregateFunctions.Max:
copyOfSubset = copyOfSubset.max(`${column.name} as tbResult`);
break;
case AggregateFunctions.Min:
copyOfSubset = copyOfSubset.min(`${column.name} as tbResult`);
break;
case AggregateFunctions.Count:
copyOfSubset = copyOfSubset.count(`${column.name} as tbResult`);
break;
case AggregateFunctions.DistinctCount:
copyOfSubset = copyOfSubset.countDistinct(`${column.name} as tbResult`);
break;
default:
throw 'Unsupported aggregate function';
}
return copyOfSubset.then(result => ({ [column.name]: result[0].tbResult }));
}));
}