feat: 🎸 get complexity for period

src/checkpoints/checkpoints.controller.spec.ts

@@ -6,14 +6,15 @@ import { CheckpointsController } from '~/checkpoints/checkpoints.controller';
 import { CheckpointsService } from '~/checkpoints/checkpoints.service';
 import { CheckpointDetailsModel } from '~/checkpoints/models/checkpoint-details.model';
 import { CheckpointScheduleModel } from '~/checkpoints/models/checkpoint-schedule.model';
+import { PeriodComplexityModel } from '~/checkpoints/models/period-complexity.model';
 import { ScheduleComplexityModel } from '~/checkpoints/models/schedule-complexity.model';
 import { PaginatedResultsModel } from '~/common/models/paginated-results.model';
 import { ResultsModel } from '~/common/models/results.model';
 import { testValues } from '~/test-utils/consts';
 import { MockCheckpoint, MockCheckpointSchedule } from '~/test-utils/mocks';
 import { MockCheckpointsService } from '~/test-utils/service-mocks';
 
-const { did, signer, txResult } = testValues;
+const { did, signer, txResult, ticker } = testValues;
 
 describe('CheckpointsController', () => {
  let controller: CheckpointsController;
@@ -41,7 +42,6 @@ describe('CheckpointsController', () => {
  const createdAt = new Date();
  const totalSupply = new BigNumber(1000);
  const id = new BigNumber(1);
- const ticker = 'TICKER';
 
  const mockCheckpoint = new MockCheckpoint();
  mockCheckpoint.createdAt.mockResolvedValue(createdAt);
@@ -83,10 +83,7 @@ describe('CheckpointsController', () => {
  it('should return the list of Checkpoints created on an Asset', async () => {
  mockCheckpointsService.findAllByTicker.mockResolvedValue(mockCheckpoints);
 
- const result = await controller.getCheckpoints(
- { ticker: 'TICKER' },
- { size: new BigNumber(1) }
- );
+ const result = await controller.getCheckpoints({ ticker }, { size: new BigNumber(1) });
 
  expect(result).toEqual(mockResult);
  });
@@ -95,7 +92,7 @@ describe('CheckpointsController', () => {
  mockCheckpointsService.findAllByTicker.mockResolvedValue(mockCheckpoints);
 
  const result = await controller.getCheckpoints(
- { ticker: 'TICKER' },
+ { ticker },
  { size: new BigNumber(1), start: 'START_KEY' }
  );
 
@@ -115,7 +112,7 @@ describe('CheckpointsController', () => {
  signer: 'signer',
  };
 
- const result = await controller.createCheckpoint({ ticker: 'TICKER' }, body);
+ const result = await controller.createCheckpoint({ ticker }, body);
 
  expect(result).toEqual({
  ...txResult,
@@ -144,12 +141,12 @@ describe('CheckpointsController', () => {
 
  mockCheckpointsService.findSchedulesByTicker.mockResolvedValue(mockSchedules);
 
- const result = await controller.getSchedules({ ticker: 'TICKER' });
+ const result = await controller.getSchedules({ ticker });
 
  const mockResult = [
  new CheckpointScheduleModel({
  id: new BigNumber(1),
- ticker: 'TICKER',
+ ticker,
  pendingPoints: [mockDate],
  expiryDate: null,
  remainingCheckpoints: new BigNumber(1),
@@ -164,16 +161,18 @@ describe('CheckpointsController', () => {
  describe('getSchedule', () => {
  it('should call the service and return the Checkpoint Schedule details', async () => {
  const mockDate = new Date('10/14/1987');
+ // eslint-disable-next-line @typescript-eslint/no-unused-vars
+ const { getCheckpoints, ...schedule } = new MockCheckpointSchedule();
  const mockScheduleWithDetails = {
- schedule: new MockCheckpointSchedule(),
+ schedule,
  details: {
  remainingCheckpoints: new BigNumber(1),
  nextCheckpointDate: mockDate,
  },
  };
  mockCheckpointsService.findScheduleById.mockResolvedValue(mockScheduleWithDetails);
 
- const result = await controller.getSchedule({ ticker: 'TICKER', id: new BigNumber(1) });
+ const result = await controller.getSchedule({ ticker, id: new BigNumber(1) });
 
  const mockResult = new CheckpointScheduleModel({
  id: mockScheduleWithDetails.schedule.id,
@@ -197,8 +196,10 @@ describe('CheckpointsController', () => {
  };
  mockCheckpointsService.createScheduleByTicker.mockResolvedValue(response);
 
+ // eslint-disable-next-line @typescript-eslint/no-unused-vars
+ const { getCheckpoints, ...schedule } = new MockCheckpointSchedule();
  const mockScheduleWithDetails = {
- schedule: new MockCheckpointSchedule(),
+ schedule,
  details: {
  remainingCheckpoints: new BigNumber(1),
  nextCheckpointDate: mockDate,
@@ -211,7 +212,7 @@ describe('CheckpointsController', () => {
  points: [mockDate],
  };
 
- const result = await controller.createSchedule({ ticker: 'TICKER' }, body);
+ const result = await controller.createSchedule({ ticker }, body);
 
  const mockCreatedSchedule = new CheckpointScheduleModel({
  id: mockScheduleWithDetails.schedule.id,
@@ -262,7 +263,7 @@ describe('CheckpointsController', () => {
 
  const result = await controller.getHolders(
  {
- ticker: 'TICKER',
+ ticker,
  id: new BigNumber(1),
  },
  { size: new BigNumber(10) }
@@ -275,7 +276,6 @@ describe('CheckpointsController', () => {
  describe('getAssetBalance', () => {
  it('should return the balance of an Asset for an Identity at a given Checkpoint', async () => {
  const balance = new BigNumber(10);
- const ticker = 'TICKER';
  const id = new BigNumber(1);
 
  const balanceModel = new IdentityBalanceModel({ balance, identity: did });
@@ -297,10 +297,7 @@ describe('CheckpointsController', () => {
  it('should return the transaction details', async () => {
  mockCheckpointsService.deleteScheduleByTicker.mockResolvedValue(txResult);
 
- const result = await controller.deleteSchedule(
- { id: new BigNumber(1), ticker: 'TICKER' },
- { signer }
- );
+ const result = await controller.deleteSchedule({ id: new BigNumber(1), ticker }, { signer });
 
  expect(result).toEqual(txResult);
  });
@@ -311,7 +308,6 @@ describe('CheckpointsController', () => {
  const createdAt = new Date();
  const totalSupply = new BigNumber(1000);
  const id = new BigNumber(1);
- const ticker = 'TICKER';
 
  const mockCheckpoint = new MockCheckpoint();
  mockCheckpointsService.findCheckpointsByScheduleId.mockResolvedValue([
@@ -354,4 +350,28 @@ describe('CheckpointsController', () => {
  ]);
  });
  });
+
+ describe('getPeriodComplexity', () => {
+ it('should call the service and return the Checkpoint Schedule complexity for given period', async () => {
+ const complexity = new BigNumber(10000);
+ mockCheckpointsService.getComplexityForPeriod.mockResolvedValue(complexity);
+ const start = new Date();
+ const end = new Date();
+ const result = await controller.getPeriodComplexity(
+ { ticker, id: new BigNumber(1) },
+ { start, end }
+ );
+
+ const mockResult = new PeriodComplexityModel({
+ complexity,
+ });
+ expect(result).toEqual(mockResult);
+ expect(mockCheckpointsService.getComplexityForPeriod).toBeCalledWith(
+ ticker,
+ new BigNumber(1),
+ start,
+ end
+ );
+ });
+ });
 });

src/checkpoints/checkpoints.controller.ts

@@ -17,10 +17,12 @@ import { CheckpointsService } from '~/checkpoints/checkpoints.service';
 import { CheckpointParamsDto } from '~/checkpoints/dto/checkpoint.dto';
 import { CheckPointBalanceParamsDto } from '~/checkpoints/dto/checkpoint-balance.dto';
 import { CreateCheckpointScheduleDto } from '~/checkpoints/dto/create-checkpoint-schedule.dto';
+import { PeriodQueryDto } from '~/checkpoints/dto/period-query.dto';
 import { CheckpointDetailsModel } from '~/checkpoints/models/checkpoint-details.model';
 import { CheckpointScheduleModel } from '~/checkpoints/models/checkpoint-schedule.model';
 import { CreatedCheckpointModel } from '~/checkpoints/models/created-checkpoint.model';
 import { CreatedCheckpointScheduleModel } from '~/checkpoints/models/created-checkpoint-schedule.model';
+import { PeriodComplexityModel } from '~/checkpoints/models/period-complexity.model';
 import { ScheduleComplexityModel } from '~/checkpoints/models/schedule-complexity.model';
 import { ApiArrayResponse, ApiTransactionResponse } from '~/common/decorators/swagger';
 import { IsTicker } from '~/common/decorators/validation';
@@ -463,7 +465,7 @@ export class CheckpointsController {
  new CheckpointDetailsModel({ id, createdAt, totalSupply })
  );
  }
- 
+
  @ApiOperation({
  summary: 'Fetch Asset Schedules complexity',
  })
@@ -497,4 +499,52 @@ export class CheckpointsController {
  });
  });
  }
+
+ @ApiOperation({
+ summary: 'Fetch details of an Asset Checkpoint Schedule',
+ })
+ @ApiParam({
+ name: 'ticker',
+ description: 'The ticker of the Asset whose Checkpoint Schedule is to be fetched',
+ type: 'string',
+ example: 'TICKER',
+ })
+ @ApiParam({
+ name: 'id',
+ description: 'The ID of the Checkpoint Schedule to be fetched',
+ type: 'string',
+ example: '1',
+ })
+ @ApiQuery({
+ name: 'start',
+ description: 'Start date for the period for which to fetch complexity',
+ type: 'string',
+ required: false,
+ example: '2021-01-01',
+ })
+ @ApiQuery({
+ name: 'end',
+ description: 'End date for the period for which to fetch complexity',
+ type: 'string',
+ required: false,
+ example: '2021-01-31',
+ })
+ @ApiOkResponse({
+ description: 'The complexity of the Schedule for the given period',
+ type: ScheduleComplexityModel,
+ })
+ @ApiNotFoundResponse({
+ description: 'Either the Asset or the Checkpoint Schedule does not exist',
+ })
+ @Get('schedules/:id/complexity')
+ public async getPeriodComplexity(
+ @Param() { ticker, id }: CheckpointScheduleParamsDto,
+ @Query() { start, end }: PeriodQueryDto
+ ): Promise<PeriodComplexityModel> {
+ const complexity = await this.checkpointsService.getComplexityForPeriod(ticker, id, start, end);
+
+ return new PeriodComplexityModel({
+ complexity,
+ });
+ }
 }

src/checkpoints/checkpoints.service.spec.ts

@@ -477,4 +477,66 @@ describe('CheckpointsService', () => {
  expect(mockAssetsService.findFungible).toBeCalledWith('TICKER');
  });
  });
+
+ describe('getComplexityForPeriod', () => {
+ let mockAsset: MockAsset;
+ const ticker = 'TICKER';
+ const id = new BigNumber(1);
+
+ const CHECKPOINT_DATE = new Date('2021-01-01');
+ const START_DATE = new Date('2021-01-15');
+ const END_DATE = new Date('2021-01-31');
+ const PENDING_POINT_DATE_1 = new Date('2021-01-21');
+ const PENDING_POINT_DATE_2 = new Date('2021-01-15');
+
+ beforeEach(() => {
+ mockAsset = new MockAsset();
+ mockAssetsService.findFungible.mockResolvedValue(mockAsset);
+ });
+
+ const setupMocks = (createdAtDate: Date, pendingPoints: Date[] = []): void => {
+ const schedule = new MockCheckpointSchedule();
+ schedule.pendingPoints = pendingPoints;
+ const mockCheckpoint = new MockCheckpoint();
+ mockCheckpoint.createdAt.mockResolvedValue(createdAtDate);
+ schedule.getCheckpoints.mockResolvedValue([mockCheckpoint]);
+
+ const mockScheduleWithDetails = {
+ schedule,
+ };
+ mockAsset.checkpoints.schedules.getOne.mockResolvedValue(mockScheduleWithDetails);
+ };
+
+ it('should equal the length of all checkpoints for schedule if no period given', async () => {
+ setupMocks(new Date());
+
+ const result = await service.getComplexityForPeriod(ticker, id);
+
+ expect(result).toEqual(new BigNumber(1));
+ });
+
+ it('should filter out checkpoints that are outside given period', async () => {
+ setupMocks(CHECKPOINT_DATE, [PENDING_POINT_DATE_2]);
+
+ const result = await service.getComplexityForPeriod(ticker, id, START_DATE, END_DATE);
+
+ expect(result).toEqual(new BigNumber(1));
+ });
+
+ it('should filter if just start is given', async () => {
+ setupMocks(CHECKPOINT_DATE, [PENDING_POINT_DATE_1]);
+
+ const result = await service.getComplexityForPeriod(ticker, id, START_DATE);
+
+ expect(result).toEqual(new BigNumber(1));
+ });
+
+ it('should filter if just end is given', async () => {
+ setupMocks(CHECKPOINT_DATE, [PENDING_POINT_DATE_1]);
+
+ const result = await service.getComplexityForPeriod(ticker, id, undefined, START_DATE);
+
+ expect(result).toEqual(new BigNumber(1));
+ });
+ });
 });

src/checkpoints/checkpoints.service.ts

@@ -152,4 +152,27 @@ export class CheckpointsService {
 
  return { schedules, maxComplexity };
  }
+
+ public async getComplexityForPeriod(
+ ticker: string,
+ id: BigNumber,
+ start?: Date,
+ end?: Date
+ ): Promise<BigNumber> {
+ const { schedule } = await this.findScheduleById(ticker, id);
+
+ const checkpoints = await schedule.getCheckpoints();
+ const pendingPoints = schedule.pendingPoints;
+ const checkpointDatePromises = checkpoints.map(checkpoint => checkpoint.createdAt());
+
+ const pastCheckpoints = await Promise.all(checkpointDatePromises);
+
+ const allCheckpoints = [...pendingPoints, ...pastCheckpoints];
+
+ const checkpointsInPeriod = allCheckpoints.filter(
+ date => (!start || date >= start) && (!end || date <= end)
+ );
+
+ return new BigNumber(checkpointsInPeriod.length);
+ }
 }

src/checkpoints/dto/period-query.dto.ts

@@ -0,0 +1,13 @@
+/* istanbul ignore file */
+
+import { IsDate, IsOptional } from 'class-validator';
+
+export class PeriodQueryDto {
+ @IsOptional()
+ @IsDate()
+ readonly start?: Date;
+
+ @IsOptional()
+ @IsDate()
+ readonly end?: Date;
+}

src/checkpoints/models/period-complexity.model.ts

@@ -0,0 +1,20 @@
+/* istanbul ignore file */
+
+import { ApiProperty } from '@nestjs/swagger';
+import { BigNumber } from '@polymeshassociation/polymesh-sdk';
+
+import { FromBigNumber } from '~/common/decorators/transformation';
+
+export class PeriodComplexityModel {
+ @ApiProperty({
+ description: 'Total calculated complexity for given period',
+ type: 'string',
+ example: '10000',
+ })
+ @FromBigNumber()
+ readonly complexity: BigNumber;
+
+ constructor(model: PeriodComplexityModel) {
+ Object.assign(this, model);
+ }
+}

src/test-utils/service-mocks.ts

@@ -221,6 +221,7 @@ export class MockCheckpointsService {
  findOne = jest.fn();
  findCheckpointsByScheduleId = jest.fn();
  getComplexityForAsset = jest.fn();
+ getComplexityForPeriod = jest.fn();
 }
 
 export class MockAuthService {