#9106

Committed 22 Jan 2025 04:03PM UTC coverage: 14.35%. First build

Build # #9106

Build Type

Pull #4814

travis-ci

Pull Request Pull Request #4814: RoleSet on organizations + platform

Run Details

84 of 4951 branches covered (1.7%)

Branch coverage included in aggregate %.

48 of 312 new or added lines in 27 files covered. (15.38%)

2292 of 11606 relevant lines covered (19.75%)

7.15 hits per line

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

12.79

/src/platform/platform/platform.service.ts

import { LogContext } from '@common/enums/logging.context';
import { EntityNotFoundException } from '@common/exceptions/entity.not.found.exception';
import { ILibrary } from '@library/library/library.interface';
import { Inject, Injectable, LoggerService } from '@nestjs/common';
import { InjectRepository } from '@nestjs/typeorm';
import { WINSTON_MODULE_NEST_PROVIDER } from 'nest-winston';
import {
  EntityManager,
  FindOneOptions,
  FindOptionsRelations,
  Repository,
} from 'typeorm';
import { Platform } from './platform.entity';
import { IPlatform } from './platform.interface';
import { IStorageAggregator } from '@domain/storage/storage-aggregator/storage.aggregator.interface';
import { IAuthorizationPolicy } from '@domain/common/authorization-policy';
import { ReleaseDiscussionOutput } from './dto/release.discussion.dto';
import { ForumService } from '@platform/forum/forum.service';
import { IForum } from '@platform/forum/forum.interface';
import { ForumDiscussionCategory } from '@common/enums/forum.discussion.category';
import { MessagingService } from '@domain/communication/messaging/messaging.service';
import { IMessaging } from '@domain/communication/messaging/messaging.interface';
import { Discussion } from '@platform/forum-discussion/discussion.entity';
import { ITemplatesManager } from '@domain/template/templates-manager/templates.manager.interface';
import { ILicensingFramework } from '@platform/licensing/credential-based/licensing-framework/licensing.framework.interface';
import { IRoleSet } from '@domain/access/role-set';

@Injectable()
export class PlatformService {
  constructor(
    private forumService: ForumService,
    private readonly messagingService: MessagingService,
    private entityManager: EntityManager,
    @InjectRepository(Platform)
    private platformRepository: Repository<Platform>,
    @Inject(WINSTON_MODULE_NEST_PROVIDER) private readonly logger: LoggerService
  ) {}

  async getPlatformOrFail(
    options?: FindOneOptions<Platform>
  ): Promise<IPlatform | never> {
    let platform: IPlatform | null = null;
    platform = (
      await this.platformRepository.find({ take: 1, ...options })
    )?.[0];

    if (!platform) {
      throw new EntityNotFoundException(
        'No Platform found!',
        LogContext.PLATFORM
      );
    }

    // Ensure notificationEmailBlacklist is initialized
    if (platform.settings?.integration) {
      if (!platform.settings.integration.notificationEmailBlacklist) {
        platform.settings.integration.notificationEmailBlacklist = [];
      }
    }

    return platform;
  }

  async savePlatform(platform: IPlatform): Promise<IPlatform> {
    return await this.platformRepository.save(platform);
  }

  async getLibraryOrFail(
    relations?: FindOptionsRelations<IPlatform>
  ): Promise<ILibrary> {
    const platform = await this.getPlatformOrFail({
      relations: { library: true, ...relations },
    });
    const library = platform.library;
    if (!library) {
      throw new EntityNotFoundException(
        'No Platform Library found!',
        LogContext.PLATFORM
      );
    }
    return library;
  }

  async getForumOrFail(): Promise<IForum> {
    const platform = await this.getPlatformOrFail({
      relations: { forum: true },
    });
    const forum = platform.forum;
    if (!forum) {
      throw new EntityNotFoundException(
        'No Platform Forum found!',
        LogContext.PLATFORM
      );
    }
    return forum;
  }

  async getTemplatesManagerOrFail(): Promise<ITemplatesManager> {
    const platform = await this.getPlatformOrFail({
      relations: { templatesManager: true },
    });
    if (!platform || !platform.templatesManager) {
      throw new EntityNotFoundException(
        'Unable to find templatesManager for platform',
        LogContext.PLATFORM
      );
    }

    return platform.templatesManager;
  }

  async ensureForumCreated(): Promise<IForum> {
    const platform = await this.getPlatformOrFail({
      relations: { forum: true },
    });
    const forum = platform.forum;
    if (!forum) {
      // Forum is a direct child of Platform. Since Platform has no Matrix Space,
      // Forum becomes a root-level Matrix Space (no parent).
      platform.forum = await this.forumService.createForum(
        Object.values(ForumDiscussionCategory)
      );
      await this.savePlatform(platform);
      return platform.forum;
    }
    return forum;
  }

  async ensureMessagingCreated(): Promise<IMessaging> {
    const platform = await this.getPlatformOrFail({
      relations: { messaging: true },
    });
    const messaging = platform.messaging;
    if (!messaging) {
      platform.messaging = await this.messagingService.createMessaging();
      await this.savePlatform(platform);
      return platform.messaging;
    }
    return messaging;
  }

  /**
   * @deprecated Use ensureMessagingCreated instead
   */
  async ensureConversationsSetCreated(): Promise<IMessaging> {
    return this.ensureMessagingCreated();
  }

  async getStorageAggregator(
    platformInput: IPlatform
  ): Promise<IStorageAggregator> {
    const platform = await this.getPlatformOrFail({
      relations: {
        storageAggregator: true,
      },
    });
    const storageAggregator = platform.storageAggregator;

    if (!storageAggregator) {
      throw new EntityNotFoundException(
        `Unable to find storage aggregator for Platform: ${platformInput.id}`,
        LogContext.PLATFORM
      );
    }

    return storageAggregator;
  }

  async getLicensingFramework(
    platformInput: IPlatform
  ): Promise<ILicensingFramework> {
    const platform = await this.getPlatformOrFail({
      relations: {
        licensingFramework: true,
      },
    });
    const licensing = platform.licensingFramework;

    if (!licensing) {
      throw new EntityNotFoundException(
        `Unable to find Licensing for Platform: ${platformInput.id}`,
        LogContext.PLATFORM
      );
    }

    return licensing;
  }

  async getRoleSetOrFail(): Promise<IRoleSet | never> {
    const platform = await this.getPlatformOrFail({
      relations: {
        roleSet: true,
      },
    });
    const roleSet = platform.roleSet;

    if (!roleSet) {
      throw new EntityNotFoundException(
        'Unable to find RoleSet for Platform',
        LogContext.PLATFORM
      );
    }

    return roleSet;
  }

  getAuthorizationPolicy(platform: IPlatform): IAuthorizationPolicy {
    const authorization = platform.authorization;

    if (!authorization) {
      throw new EntityNotFoundException(
        `Unable to find Authorization Policy for Platform: ${platform.id}`,
        LogContext.PLATFORM
      );
    }

    return authorization;
  }

  public async getLatestReleaseDiscussion(): Promise<
    ReleaseDiscussionOutput | undefined
  > {
    let latestDiscussion: Discussion | undefined;
    try {
      latestDiscussion = await this.entityManager
        .getRepository(Discussion)
        .findOneOrFail({
          where: { category: ForumDiscussionCategory.RELEASES },
          order: { createdDate: 'DESC' },
        });
    } catch {
      return undefined;
    }

    return { nameID: latestDiscussion.nameID, id: latestDiscussion.id };
  }
}

1	import { LogContext } from '@common/enums/logging.context';	54✔
2	import { EntityNotFoundException } from '@common/exceptions/entity.not.found.exception';	54✔
3	import { ILibrary } from '@library/library/library.interface';
4	import { Inject, Injectable, LoggerService } from '@nestjs/common';	54✔
5	import { InjectRepository } from '@nestjs/typeorm';	54✔
6	import { WINSTON_MODULE_NEST_PROVIDER } from 'nest-winston';	54✔
7	import {	54✔
8	EntityManager,
9	FindOneOptions,
10	FindOptionsRelations,
11	Repository,
12	} from 'typeorm';
13	import { Platform } from './platform.entity';	54✔
14	import { IPlatform } from './platform.interface';
15	import { IStorageAggregator } from '@domain/storage/storage-aggregator/storage.aggregator.interface';
16	import { IAuthorizationPolicy } from '@domain/common/authorization-policy';
17	import { ReleaseDiscussionOutput } from './dto/release.discussion.dto';
18	import { ForumService } from '@platform/forum/forum.service';	54✔
19	import { IForum } from '@platform/forum/forum.interface';
20	import { ForumDiscussionCategory } from '@common/enums/forum.discussion.category';	54✔
21	import { MessagingService } from '@domain/communication/messaging/messaging.service';	54✔
22	import { IMessaging } from '@domain/communication/messaging/messaging.interface';
23	import { Discussion } from '@platform/forum-discussion/discussion.entity';
24	import { ITemplatesManager } from '@domain/template/templates-manager/templates.manager.interface';
25	import { ILicensingFramework } from '@platform/licensing/credential-based/licensing-framework/licensing.framework.interface';
26	import { IRoleSet } from '@domain/access/role-set';
27
28	@Injectable()	54✔
29	export class PlatformService {
30	constructor(	×
31	private forumService: ForumService,	×
32	private readonly messagingService: MessagingService,
33	private entityManager: EntityManager,	×
34	@InjectRepository(Platform)	×
35	private platformRepository: Repository<Platform>,
36	@Inject(WINSTON_MODULE_NEST_PROVIDER) private readonly logger: LoggerService
37	) {}
38
39	async getPlatformOrFail(
40	options?: FindOneOptions<Platform>	×
41	): Promise<IPlatform \| never> {	×
42	let platform: IPlatform \| null = null;
43	platform = (
44	await this.platformRepository.find({ take: 1, ...options })
45	)?.[0];	×
46		×
47	if (!platform) {
48	throw new EntityNotFoundException(
49	'No Platform found!',
50	LogContext.PLATFORM
51	);	×
52	}
53
54	// Ensure notificationEmailBlacklist is initialized
55	if (platform.settings?.integration) {	×
56	if (!platform.settings.integration.notificationEmailBlacklist) {
57	platform.settings.integration.notificationEmailBlacklist = [];
58	}
59	}
60
61	return platform;	×
62	}
63
64	async savePlatform(platform: IPlatform): Promise<IPlatform> {	×
65	return await this.platformRepository.save(platform);	×
66	}	×
67
68	async getLibraryOrFail(
69	relations?: FindOptionsRelations<IPlatform>
70	): Promise<ILibrary> {
71	const platform = await this.getPlatformOrFail({	×
72	relations: { library: true, ...relations },
73	});
74	const library = platform.library;
75	if (!library) {	×
76	throw new EntityNotFoundException(
77	'No Platform Library found!',
78	LogContext.PLATFORM	×
79	);	×
80	}	×
81	return library;
82	}
83
84	async getForumOrFail(): Promise<IForum> {
85	const platform = await this.getPlatformOrFail({	×
86	relations: { forum: true },
87	});
88	const forum = platform.forum;
89	if (!forum) {	×
90	throw new EntityNotFoundException(
91	'No Platform Forum found!',
92	LogContext.PLATFORM	×
93	);	×
94	}
95	return forum;
96	}
97
98	async getTemplatesManagerOrFail(): Promise<ITemplatesManager> {
99	const platform = await this.getPlatformOrFail({	×
100	relations: { templatesManager: true },
101	});
102	if (!platform \|\| !platform.templatesManager) {
103	throw new EntityNotFoundException(	×
104	'Unable to find templatesManager for platform',
105	LogContext.PLATFORM
106	);	×
107	}	×
108		×
109	return platform.templatesManager;
110	}
111		×
112	async ensureForumCreated(): Promise<IForum> {	×
113	const platform = await this.getPlatformOrFail({
114	relations: { forum: true },	×
115	});
116	const forum = platform.forum;
117	if (!forum) {
118	// Forum is a direct child of Platform. Since Platform has no Matrix Space,
119	// Forum becomes a root-level Matrix Space (no parent).
120	platform.forum = await this.forumService.createForum(	×
121	Object.values(ForumDiscussionCategory)
122	);
123	await this.savePlatform(platform);
124	return platform.forum;
125	}	×
126	return forum;
127	}	×
128		×
129	async ensureMessagingCreated(): Promise<IMessaging> {
130	const platform = await this.getPlatformOrFail({
131	relations: { messaging: true },
132	});
133	const messaging = platform.messaging;
134	if (!messaging) {	×
135	platform.messaging = await this.messagingService.createMessaging();
136	await this.savePlatform(platform);
137	return platform.messaging;
138	}	×
139	return messaging;
140	}
141
142	/**
143	* @deprecated Use ensureMessagingCreated instead
144	*/
145	async ensureConversationsSetCreated(): Promise<IMessaging> {	×
146	return this.ensureMessagingCreated();	×
147	}	×
148
149	async getStorageAggregator(
150	platformInput: IPlatform
151	): Promise<IStorageAggregator> {
152	const platform = await this.getPlatformOrFail({	×
153	relations: {
154	storageAggregator: true,
155	},
156	});
157	const storageAggregator = platform.storageAggregator;
158		×
159	if (!storageAggregator) {
160	throw new EntityNotFoundException(
161	`Unable to find storage aggregator for Platform: ${platformInput.id}`,
162	LogContext.PLATFORM
163	);	×
164	}
165		×
166	return storageAggregator;	×
167	}
168
169	async getLicensingFramework(
170	platformInput: IPlatform
171	): Promise<ILicensingFramework> {
172	const platform = await this.getPlatformOrFail({	×
173	relations: {
174	licensingFramework: true,
175	},
NEW 176	});	×
177	const licensing = platform.licensingFramework;
178
179	if (!licensing) {
180	throw new EntityNotFoundException(
NEW 181	`Unable to find Licensing for Platform: ${platformInput.id}`,	×
182	LogContext.PLATFORM
NEW 183	);	×
NEW 184	}	×
185
186	return licensing;
187	}
188
189	async getRoleSetOrFail(): Promise<IRoleSet \| never> {
NEW 190	const platform = await this.getPlatformOrFail({	×
191	relations: {
192	roleSet: true,
193	},
194	});	×
195	const roleSet = platform.roleSet;
196		×
197	if (!roleSet) {	×
198	throw new EntityNotFoundException(
199	'Unable to find RoleSet for Platform',
200	LogContext.PLATFORM
201	);
202	}
203		×
204	return roleSet;
205	}
206
207	getAuthorizationPolicy(platform: IPlatform): IAuthorizationPolicy {
208	const authorization = platform.authorization;
209
210	if (!authorization) {	×
211	throw new EntityNotFoundException(	×
212	`Unable to find Authorization Policy for Platform: ${platform.id}`,
213	LogContext.PLATFORM
214	);
215	}
216
217	return authorization;
218	}	×
219
220	public async getLatestReleaseDiscussion(): Promise<
221	ReleaseDiscussionOutput \| undefined	×
222	> {
223	let latestDiscussion: Discussion \| undefined;
224	try {
225	latestDiscussion = await this.entityManager
226	.getRepository(Discussion)
227	.findOneOrFail({
228	where: { category: ForumDiscussionCategory.RELEASES },
229	order: { createdDate: 'DESC' },
230	});
231	} catch {
232	return undefined;
233	}
234
235	return { nameID: latestDiscussion.nameID, id: latestDiscussion.id };
236	}
237	}

alkem-io / server / #9106

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