#8050

Committed 16 Aug 2024 11:21AM UTC coverage: 13.92%. First build

Build # #8050

Build Type

Pull #4411

travis-ci

Pull Request Pull Request #4411: Type added to authorization policy entity

Run Details

80 of 4158 branches covered (1.92%)

Branch coverage included in aggregate %.

61 of 116 new or added lines in 50 files covered. (52.59%)

1945 of 10389 relevant lines covered (18.72%)

3.01 hits per line

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

14.6

/src/domain/community/user-group/user-group.service.ts

import { Inject, Injectable, LoggerService } from '@nestjs/common';
import { InjectRepository } from '@nestjs/typeorm';
import { FindOneOptions, Repository, FindManyOptions } from 'typeorm';
import { IGroupable } from '@src/common/interfaces/groupable.interface';
import { ProfileService } from '@domain/common/profile/profile.service';
import { IUser } from '@domain/community/user/user.interface';
import { WINSTON_MODULE_NEST_PROVIDER } from 'nest-winston';
import {
  AuthorizationCredential,
  LogContext,
  ProfileType,
} from '@common/enums';
import {
  EntityNotFoundException,
  NotSupportedException,
  EntityNotInitializedException,
} from '@common/exceptions';
import { UserGroup, IUserGroup } from '@domain/community/user-group';
import { AgentService } from '@domain/agent/agent/agent.service';
import { AuthorizationPolicy } from '@domain/common/authorization-policy';
import { IProfile } from '@domain/common/profile';
import { AuthorizationPolicyService } from '@domain/common/authorization-policy/authorization.policy.service';
import {
  AssignUserGroupMemberInput,
  CreateUserGroupInput,
  DeleteUserGroupInput,
  RemoveUserGroupMemberInput,
  UpdateUserGroupInput,
} from './dto';
import { IStorageAggregator } from '@domain/storage/storage-aggregator/storage.aggregator.interface';
import { AuthorizationPolicyType } from '@common/enums/authorization.policy.type';
import { UserLookupService } from '../user-lookup/user.lookup.service';

@Injectable()
export class UserGroupService {
  constructor(
    private authorizationPolicyService: AuthorizationPolicyService,
    private userLookupService: UserLookupService,
    private profileService: ProfileService,
    private agentService: AgentService,
    @InjectRepository(UserGroup)
    private userGroupRepository: Repository<UserGroup>,
    @Inject(WINSTON_MODULE_NEST_PROVIDER) private readonly logger: LoggerService
  ) {}

  async createUserGroup(
    userGroupData: CreateUserGroupInput,
    storageAggregator: IStorageAggregator
  ): Promise<IUserGroup> {
    const group = UserGroup.create(userGroupData);
    group.authorization = new AuthorizationPolicy(
      AuthorizationPolicyType.USER_GROUP
    );

    (group as IUserGroup).profile = await this.profileService.createProfile(
      userGroupData.profile,
      ProfileType.USER_GROUP,
      storageAggregator
    );
    const savedUserGroup = await this.userGroupRepository.save(group);
    this.logger.verbose?.(
      `Created new group (${group.id}) with name: ${group.profile?.displayName}`,
      LogContext.COMMUNITY
    );
    return savedUserGroup;
  }
  async removeUserGroup(deleteData: DeleteUserGroupInput): Promise<IUserGroup> {
    const groupID = deleteData.ID;
    // Note need to load it in with all contained entities so can remove fully
    const group = (await this.getUserGroupOrFail(groupID)) as UserGroup;

    if (group.profile) {
      await this.profileService.deleteProfile(group.profile.id);
    }

    if (group.authorization)
      await this.authorizationPolicyService.delete(group.authorization);

    // Remove all issued membership credentials
    const members = await this.getMembers(group.id);
    for (const member of members) {
      await this.removeUser({ userID: member.id, groupID: group.id });
    }

    const { id } = group;
    const result = await this.userGroupRepository.remove(group);
    return {
      ...result,
      id,
    };
  }

  async updateUserGroup(
    userGroupInput: UpdateUserGroupInput
  ): Promise<IUserGroup> {
    const group = await this.getUserGroupOrFail(userGroupInput.ID, {
      relations: { profile: true },
    });
    if (!group.profile) {
      throw new EntityNotFoundException(
        `Group profile not initialised: ${group.id}`,
        LogContext.COMMUNITY
      );
    }

    const newName = userGroupInput.name;
    if (
      newName &&
      newName.length > 0 &&
      newName !== group.profile.displayName
    ) {
      group.profile.displayName = newName;
    }

    if (userGroupInput.profileData) {
      group.profile = await this.profileService.updateProfile(
        group.profile,
        userGroupInput.profileData
      );
    }

    return await this.userGroupRepository.save(group);
  }

  async saveUserGroup(group: IUserGroup): Promise<IUserGroup> {
    return await this.userGroupRepository.save(group);
  }

  async getParent(group: IUserGroup): Promise<IGroupable> {
    const groupWithParent = (await this.getUserGroupOrFail(group.id, {
      relations: { community: true, organization: true },
    })) as UserGroup;
    if (groupWithParent?.community) return groupWithParent?.community;
    if (groupWithParent?.organization) return groupWithParent?.organization;
    throw new EntityNotFoundException(
      `Unable to locate parent for user group: ${group.profile?.displayName}`,
      LogContext.COMMUNITY
    );
  }

  async getUserGroupOrFail(
    groupID: string,
    options?: FindOneOptions<UserGroup>
  ): Promise<IUserGroup | never> {
    //const t1 = performance.now()

    const group = await this.userGroupRepository.findOne({
      ...options,
      where: {
        ...options?.where,
        id: groupID,
      },
    });

    if (!group)
      throw new EntityNotFoundException(
        `Unable to find group with ID: ${groupID}`,
        LogContext.COMMUNITY
      );
    return group;
  }

  async assignUser(
    membershipData: AssignUserGroupMemberInput
  ): Promise<IUserGroup> {
    const { user, agent } = await this.userLookupService.getUserAndAgent(
      membershipData.userID
    );

    user.agent = await this.agentService.grantCredentialOrFail({
      agentID: agent.id,
      type: AuthorizationCredential.USER_GROUP_MEMBER,
      resourceID: membershipData.groupID,
    });

    return await this.getUserGroupOrFail(membershipData.groupID, {
      relations: { community: true },
    });
  }

  async removeUser(
    membershipData: RemoveUserGroupMemberInput
  ): Promise<IUserGroup> {
    const { user, agent } = await this.userLookupService.getUserAndAgent(
      membershipData.userID
    );

    user.agent = await this.agentService.revokeCredential({
      agentID: agent.id,
      type: AuthorizationCredential.USER_GROUP_MEMBER,
      resourceID: membershipData.groupID,
    });

    return await this.getUserGroupOrFail(membershipData.groupID, {
      relations: { community: true },
    });
  }

  private hasGroupWithName(groupable: IGroupable, name: string): boolean {
    // Double check groups array is initialised
    if (!groupable.groups) {
      throw new EntityNotInitializedException(
        'Non-initialised Groupable submitted',
        LogContext.COMMUNITY
      );
    }

    // Find the right group
    for (const group of groupable.groups) {
      if (group.profile?.displayName === name) {
        return true;
      }
    }

    // If get here then no match group was found
    return false;
  }

  async addGroupWithName(
    groupable: IGroupable,
    name: string,
    storageAggregator: IStorageAggregator
  ): Promise<IUserGroup> {
    // Check if the group already exists, if so log a warning
    const alreadyExists = this.hasGroupWithName(groupable, name);
    if (alreadyExists) {
      throw new NotSupportedException(
        `Unable to create user group as parent already has a group with the given name: ${name}`,
        LogContext.COMMUNITY
      );
    }

    const newGroup = await this.createUserGroup(
      {
        parentID: groupable.id,
        profile: {
          displayName: name,
        },
      },
      storageAggregator
    );
    await groupable.groups?.push(newGroup);
    return newGroup;
  }

  async getMembers(groupID: string): Promise<IUser[]> {
    return await this.userLookupService.usersWithCredential({
      type: AuthorizationCredential.USER_GROUP_MEMBER,
      resourceID: groupID,
    });
  }

  async getGroups(
    conditions?: FindManyOptions<UserGroup>
  ): Promise<IUserGroup[]> {
    return (await this.userGroupRepository.find(conditions)) || [];
  }

  getProfile(userGroup: IUserGroup): IProfile {
    const profile = userGroup.profile;
    if (!profile)
      throw new EntityNotInitializedException(
        `UserGroup Profile not initialized: ${userGroup.id}`,
        LogContext.COMMUNITY
      );
    return profile;
  }
}

1	import { Inject, Injectable, LoggerService } from '@nestjs/common';	24✔
2	import { InjectRepository } from '@nestjs/typeorm';	24✔
3	import { FindOneOptions, Repository, FindManyOptions } from 'typeorm';	24✔
4	import { IGroupable } from '@src/common/interfaces/groupable.interface';
5	import { ProfileService } from '@domain/common/profile/profile.service';	24✔
6	import { IUser } from '@domain/community/user/user.interface';
7	import { WINSTON_MODULE_NEST_PROVIDER } from 'nest-winston';	24✔
8	import {	24✔
9	AuthorizationCredential,	24✔
10	LogContext,
11	ProfileType,
12	} from '@common/enums';
13	import {
14	EntityNotFoundException,	24✔
15	NotSupportedException,
16	EntityNotInitializedException,
17	} from '@common/exceptions';
18	import { UserGroup, IUserGroup } from '@domain/community/user-group';
19	import { AgentService } from '@domain/agent/agent/agent.service';	24✔
20	import { AuthorizationPolicy } from '@domain/common/authorization-policy';	24✔
21	import { IProfile } from '@domain/common/profile';	24✔
22	import { AuthorizationPolicyService } from '@domain/common/authorization-policy/authorization.policy.service';
23	import {	24✔
24	AssignUserGroupMemberInput,
25	CreateUserGroupInput,
26	DeleteUserGroupInput,
27	RemoveUserGroupMemberInput,
28	UpdateUserGroupInput,
29	} from './dto';
30	import { IStorageAggregator } from '@domain/storage/storage-aggregator/storage.aggregator.interface';
31	import { AuthorizationPolicyType } from '@common/enums/authorization.policy.type';
32	import { UserLookupService } from '../user-lookup/user.lookup.service';	24✔
33
34	@Injectable()
35	export class UserGroupService {	24✔
36	constructor(
37	private authorizationPolicyService: AuthorizationPolicyService,	1✔
38	private userLookupService: UserLookupService,	1✔
39	private profileService: ProfileService,	1✔
40	private agentService: AgentService,	1✔
41	@InjectRepository(UserGroup)
42	private userGroupRepository: Repository<UserGroup>,	1✔
43	@Inject(WINSTON_MODULE_NEST_PROVIDER) private readonly logger: LoggerService	1✔
44	) {}
45
46	async createUserGroup(
47	userGroupData: CreateUserGroupInput,
48	storageAggregator: IStorageAggregator
49	): Promise<IUserGroup> {
50	const group = UserGroup.create(userGroupData);	×
NEW 51	group.authorization = new AuthorizationPolicy(	×
52	AuthorizationPolicyType.USER_GROUP
53	);
54
55	(group as IUserGroup).profile = await this.profileService.createProfile(	×
56	userGroupData.profile,
57	ProfileType.USER_GROUP,
58	storageAggregator
59	);
60	const savedUserGroup = await this.userGroupRepository.save(group);	×
61	this.logger.verbose?.(	×
62	`Created new group (${group.id}) with name: ${group.profile?.displayName}`,	×
63	LogContext.COMMUNITY
64	);
65	return savedUserGroup;	×
66	}
67	async removeUserGroup(deleteData: DeleteUserGroupInput): Promise<IUserGroup> {
68	const groupID = deleteData.ID;	×
69	// Note need to load it in with all contained entities so can remove fully
70	const group = (await this.getUserGroupOrFail(groupID)) as UserGroup;	×
71
72	if (group.profile) {	×
73	await this.profileService.deleteProfile(group.profile.id);	×
74	}
75
76	if (group.authorization)	×
77	await this.authorizationPolicyService.delete(group.authorization);	×
78
79	// Remove all issued membership credentials
80	const members = await this.getMembers(group.id);	×
81	for (const member of members) {	×
82	await this.removeUser({ userID: member.id, groupID: group.id });	×
83	}
84
85	const { id } = group;	×
86	const result = await this.userGroupRepository.remove(group);	×
87	return {	×
88	...result,
89	id,
90	};
91	}
92
93	async updateUserGroup(
94	userGroupInput: UpdateUserGroupInput
95	): Promise<IUserGroup> {
96	const group = await this.getUserGroupOrFail(userGroupInput.ID, {	×
97	relations: { profile: true },
98	});
99	if (!group.profile) {	×
100	throw new EntityNotFoundException(	×
101	`Group profile not initialised: ${group.id}`,
102	LogContext.COMMUNITY
103	);
104	}
105
106	const newName = userGroupInput.name;	×
107	if (	×
108	newName &&	×
109	newName.length > 0 &&
110	newName !== group.profile.displayName
111	) {
112	group.profile.displayName = newName;	×
113	}
114
115	if (userGroupInput.profileData) {	×
116	group.profile = await this.profileService.updateProfile(	×
117	group.profile,
118	userGroupInput.profileData
119	);
120	}
121
122	return await this.userGroupRepository.save(group);	×
123	}
124
125	async saveUserGroup(group: IUserGroup): Promise<IUserGroup> {
126	return await this.userGroupRepository.save(group);	×
127	}
128
129	async getParent(group: IUserGroup): Promise<IGroupable> {
130	const groupWithParent = (await this.getUserGroupOrFail(group.id, {	×
131	relations: { community: true, organization: true },
132	})) as UserGroup;
133	if (groupWithParent?.community) return groupWithParent?.community;	×
134	if (groupWithParent?.organization) return groupWithParent?.organization;	×
135	throw new EntityNotFoundException(	×
136	`Unable to locate parent for user group: ${group.profile?.displayName}`,	×
137	LogContext.COMMUNITY
138	);
139	}
140
141	async getUserGroupOrFail(
142	groupID: string,
143	options?: FindOneOptions<UserGroup>
144	): Promise<IUserGroup \| never> {
145	//const t1 = performance.now()
146
147	const group = await this.userGroupRepository.findOne({	×
148	...options,
149	where: {
150	...options?.where,	×
151	id: groupID,
152	},
153	});
154
155	if (!group)	×
156	throw new EntityNotFoundException(	×
157	`Unable to find group with ID: ${groupID}`,
158	LogContext.COMMUNITY
159	);
160	return group;	×
161	}
162
163	async assignUser(
164	membershipData: AssignUserGroupMemberInput
165	): Promise<IUserGroup> {
166	const { user, agent } = await this.userLookupService.getUserAndAgent(	×
167	membershipData.userID
168	);
169
170	user.agent = await this.agentService.grantCredentialOrFail({	×
171	agentID: agent.id,
172	type: AuthorizationCredential.USER_GROUP_MEMBER,
173	resourceID: membershipData.groupID,
174	});
175
176	return await this.getUserGroupOrFail(membershipData.groupID, {	×
177	relations: { community: true },
178	});
179	}
180
181	async removeUser(
182	membershipData: RemoveUserGroupMemberInput
183	): Promise<IUserGroup> {
184	const { user, agent } = await this.userLookupService.getUserAndAgent(	×
185	membershipData.userID
186	);
187
188	user.agent = await this.agentService.revokeCredential({	×
189	agentID: agent.id,
190	type: AuthorizationCredential.USER_GROUP_MEMBER,
191	resourceID: membershipData.groupID,
192	});
193
194	return await this.getUserGroupOrFail(membershipData.groupID, {	×
195	relations: { community: true },
196	});
197	}
198
199	private hasGroupWithName(groupable: IGroupable, name: string): boolean {
200	// Double check groups array is initialised
201	if (!groupable.groups) {	×
202	throw new EntityNotInitializedException(	×
203	'Non-initialised Groupable submitted',
204	LogContext.COMMUNITY
205	);
206	}
207
208	// Find the right group
209	for (const group of groupable.groups) {	×
210	if (group.profile?.displayName === name) {	×
211	return true;	×
212	}
213	}
214
215	// If get here then no match group was found
216	return false;	×
217	}
218
219	async addGroupWithName(
220	groupable: IGroupable,
221	name: string,
222	storageAggregator: IStorageAggregator
223	): Promise<IUserGroup> {
224	// Check if the group already exists, if so log a warning
225	const alreadyExists = this.hasGroupWithName(groupable, name);	×
226	if (alreadyExists) {	×
227	throw new NotSupportedException(	×
228	`Unable to create user group as parent already has a group with the given name: ${name}`,
229	LogContext.COMMUNITY
230	);
231	}
232
233	const newGroup = await this.createUserGroup(	×
234	{
235	parentID: groupable.id,
236	profile: {
237	displayName: name,
238	},
239	},
240	storageAggregator
241	);
242	await groupable.groups?.push(newGroup);	×
243	return newGroup;	×
244	}
245
246	async getMembers(groupID: string): Promise<IUser[]> {
247	return await this.userLookupService.usersWithCredential({	×
248	type: AuthorizationCredential.USER_GROUP_MEMBER,
249	resourceID: groupID,
250	});
251	}
252
253	async getGroups(
254	conditions?: FindManyOptions<UserGroup>
255	): Promise<IUserGroup[]> {
256	return (await this.userGroupRepository.find(conditions)) \|\| [];	×
257	}
258
259	getProfile(userGroup: IUserGroup): IProfile {
260	const profile = userGroup.profile;	×
261	if (!profile)	×
262	throw new EntityNotInitializedException(	×
263	`UserGroup Profile not initialized: ${userGroup.id}`,
264	LogContext.COMMUNITY
265	);
266	return profile;	×
267	}
268	}

alkem-io / server / #8050

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