9170767425

Committed 21 May 2024 07:38AM UTC coverage: 92.819% (-0.09%) from 92.907%

Build # 9170767425

Build Type

push

github

Committed by

iamacook

Commit Message

Add campaign rank retrieval to locking API

Run Details

2026 of 2474 branches covered (81.89%)

Branch coverage included in aggregate %.

0 of 5 new or added lines in 1 file covered. (0.0%)

1 existing line in 1 file now uncovered.

7112 of 7371 relevant lines covered (96.49%)

326.35 hits per line

Source File
Press 'n' to go to next uncovered line, 'b' for previous

88.64

/src/datasources/locking-api/locking-api.service.ts

import { IConfigurationService } from '@/config/configuration.service.interface';
import { HttpErrorFactory } from '@/datasources/errors/http-error-factory';
import {
  NetworkService,
  INetworkService,
} from '@/datasources/network/network.service.interface';
import { Page } from '@/domain/entities/page.entity';
import { ILockingApi } from '@/domain/interfaces/locking-api.interface';
import { Campaign } from '@/domain/community/entities/campaign.entity';
import { CampaignRank } from '@/domain/community/entities/campaign-rank.entity';
import { LockingEvent } from '@/domain/community/entities/locking-event.entity';
import { LockingRank } from '@/domain/community/entities/locking-rank.entity';
import { Inject } from '@nestjs/common';

export class LockingApi implements ILockingApi {
  private readonly baseUri: string;

  constructor(
    @Inject(IConfigurationService)
    private readonly configurationService: IConfigurationService,
    @Inject(NetworkService)
    private readonly networkService: INetworkService,
    private readonly httpErrorFactory: HttpErrorFactory,
  ) {
    this.baseUri =
      this.configurationService.getOrThrow<string>('locking.baseUri');
  }

  async getCampaignById(resourceId: string): Promise<Campaign> {
    try {
      const url = `${this.baseUri}/api/v1/campaigns/${resourceId}`;
      const { data } = await this.networkService.get<Campaign>({ url });
      return data;
    } catch (error) {
      throw this.httpErrorFactory.from(error);
    }
  }

  async getCampaigns(args: {
    limit?: number;
    offset?: number;
  }): Promise<Page<Campaign>> {
    try {
      const url = `${this.baseUri}/api/v1/campaigns`;
      const { data } = await this.networkService.get<Page<Campaign>>({
        url,
        networkRequest: {
          params: {
            limit: args.limit,
            offset: args.offset,
          },
        },
      });
      return data;
    } catch (error) {
      throw this.httpErrorFactory.from(error);
    }
  }

  async getCampaignRank(args: {
    resourceId: string;
    safeAddress: `0x${string}`;
  }): Promise<CampaignRank> {
    try {
      const url = `${this.baseUri}/api/v1/campaigns/${args.resourceId}/${args.safeAddress}`;
      const { data } = await this.networkService.get<CampaignRank>({ url });
      return data;
    } catch (error) {
      throw this.httpErrorFactory.from(error);
    }
  }

  async getLockingRank(safeAddress: `0x${string}`): Promise<LockingRank> {
    try {
      const url = `${this.baseUri}/api/v1/leaderboard/${safeAddress}`;
      const { data } = await this.networkService.get<LockingRank>({ url });
      return data;
    } catch (error) {
      throw this.httpErrorFactory.from(error);
    }
  }

  async getLeaderboard(args: {
    limit?: number;
    offset?: number;
  }): Promise<Page<LockingRank>> {
    try {
      const url = `${this.baseUri}/api/v1/leaderboard`;
      const { data } = await this.networkService.get<Page<LockingRank>>({
        url,
        networkRequest: {
          params: {
            limit: args.limit,
            offset: args.offset,
          },
        },
      });
      return data;
    } catch (error) {
      throw this.httpErrorFactory.from(error);
    }
  }

  async getCampaignLeaderboard(args: {
    resourceId: string;
    limit?: number;
    offset?: number;
  }): Promise<Page<CampaignRank>> {
    try {
      const url = `${this.baseUri}/api/v1/campaigns/${args.resourceId}/leaderboard`;
      const { data } = await this.networkService.get<Page<CampaignRank>>({
        url,
        networkRequest: {
          params: {
            limit: args.limit,
            offset: args.offset,
          },
        },
      });
      return data;
    } catch (error) {
      throw this.httpErrorFactory.from(error);
    }
  }

  async getLockingHistory(args: {
    safeAddress: `0x${string}`;
    limit?: number;
    offset?: number;
  }): Promise<Page<LockingEvent>> {
    try {
      const url = `${this.baseUri}/api/v1/all-events/${args.safeAddress}`;
      const { data } = await this.networkService.get<Page<LockingEvent>>({
        url,
        networkRequest: {
          params: {
            limit: args.limit,
            offset: args.offset,
          },
        },
      });
      return data;
    } catch (error) {
      throw this.httpErrorFactory.from(error);
    }
  }
}

1	import { IConfigurationService } from '@/config/configuration.service.interface';	100✔
2	import { HttpErrorFactory } from '@/datasources/errors/http-error-factory';	100✔
3	import {	100✔
4	NetworkService,
5	INetworkService,
6	} from '@/datasources/network/network.service.interface';
7	import { Page } from '@/domain/entities/page.entity';
8	import { ILockingApi } from '@/domain/interfaces/locking-api.interface';
9	import { Campaign } from '@/domain/community/entities/campaign.entity';
10	import { CampaignRank } from '@/domain/community/entities/campaign-rank.entity';
11	import { LockingEvent } from '@/domain/community/entities/locking-event.entity';
12	import { LockingRank } from '@/domain/community/entities/locking-rank.entity';
13	import { Inject } from '@nestjs/common';	100✔
14
15	export class LockingApi implements ILockingApi {	100✔
16	private readonly baseUri: string;
17
18	constructor(
19	@Inject(IConfigurationService)
20	private readonly configurationService: IConfigurationService,	1,394✔
21	@Inject(NetworkService)
22	private readonly networkService: INetworkService,	1,394✔
23	private readonly httpErrorFactory: HttpErrorFactory,	1,394✔
24	) {
25	this.baseUri =	1,394✔
26	this.configurationService.getOrThrow<string>('locking.baseUri');
27	}
28
29	async getCampaignById(resourceId: string): Promise<Campaign> {
30	try {	10✔
31	const url = `${this.baseUri}/api/v1/campaigns/${resourceId}`;	10✔
32	const { data } = await this.networkService.get<Campaign>({ url });	10✔
33	return data;	6✔
34	} catch (error) {
35	throw this.httpErrorFactory.from(error);	4✔
36	}
37	}
38
39	async getCampaigns(args: {
40	limit?: number;
41	offset?: number;
42	}): Promise<Page<Campaign>> {
43	try {	14✔
44	const url = `${this.baseUri}/api/v1/campaigns`;	14✔
45	const { data } = await this.networkService.get<Page<Campaign>>({	14✔
46	url,
47	networkRequest: {
48	params: {
49	limit: args.limit,
50	offset: args.offset,
51	},
52	},
53	});
54	return data;	10✔
55	} catch (error) {
56	throw this.httpErrorFactory.from(error);	4✔
57	}
58	}
59
60	async getCampaignRank(args: {
61	resourceId: string;
62	safeAddress: `0x${string}`;
63	}): Promise<CampaignRank> {
NEW 64	try {	×
NEW 65	const url = `${this.baseUri}/api/v1/campaigns/${args.resourceId}/${args.safeAddress}`;	×
NEW 66	const { data } = await this.networkService.get<CampaignRank>({ url });	×
NEW 67	return data;	×
68	} catch (error) {
NEW 69	throw this.httpErrorFactory.from(error);	×
70	}
71	}
72
73	async getLockingRank(safeAddress: `0x${string}`): Promise<LockingRank> {
74	try {	10✔
75	const url = `${this.baseUri}/api/v1/leaderboard/${safeAddress}`;	10✔
76	const { data } = await this.networkService.get<LockingRank>({ url });	10✔
77	return data;	6✔
78	} catch (error) {
79	throw this.httpErrorFactory.from(error);	4✔
80	}
81	}
82
83	async getLeaderboard(args: {
84	limit?: number;
85	offset?: number;
86	}): Promise<Page<LockingRank>> {
87	try {	14✔
88	const url = `${this.baseUri}/api/v1/leaderboard`;	14✔
89	const { data } = await this.networkService.get<Page<LockingRank>>({	14✔
90	url,
91	networkRequest: {
92	params: {
93	limit: args.limit,
94	offset: args.offset,
95	},
96	},
97	});
98	return data;	10✔
99	} catch (error) {
100	throw this.httpErrorFactory.from(error);	4✔
101	}
102	}
103
104	async getCampaignLeaderboard(args: {
105	resourceId: string;
106	limit?: number;
107	offset?: number;
108	}): Promise<Page<CampaignRank>> {
109	try {	14✔
110	const url = `${this.baseUri}/api/v1/campaigns/${args.resourceId}/leaderboard`;	14✔
111	const { data } = await this.networkService.get<Page<CampaignRank>>({	14✔
112	url,
113	networkRequest: {
114	params: {
115	limit: args.limit,
116	offset: args.offset,
117	},
118	},
119	});
120	return data;	10✔
121	} catch (error) {
122	throw this.httpErrorFactory.from(error);	4✔
123	}
124	}
125
126	async getLockingHistory(args: {
127	safeAddress: `0x${string}`;
128	limit?: number;
129	offset?: number;
130	}): Promise<Page<LockingEvent>> {
131	try {	14✔
132	const url = `${this.baseUri}/api/v1/all-events/${args.safeAddress}`;	14✔
133	const { data } = await this.networkService.get<Page<LockingEvent>>({	14✔
134	url,
135	networkRequest: {
136	params: {
137	limit: args.limit,
138	offset: args.offset,
139	},
140	},
141	});
142	return data;	10✔
143	} catch (error) {
144	throw this.httpErrorFactory.from(error);	4✔
145	}
146	}
147	}

safe-global / safe-client-gateway / 9170767425

Source File Press 'n' to go to next uncovered line, 'b' for previous

Source File
Press 'n' to go to next uncovered line, 'b' for previous