#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

8.41

/src/domain/collaboration/collaboration/collaboration.service.ts

import { Injectable } from '@nestjs/common';
import { InjectEntityManager, InjectRepository } from '@nestjs/typeorm';
import { EntityManager, FindOneOptions, Repository } from 'typeorm';
import {
  EntityNotFoundException,
  EntityNotInitializedException,
  RelationshipNotFoundException,
} from '@common/exceptions';
import { LogContext } from '@common/enums';
import { AuthorizationPolicy } from '@domain/common/authorization-policy/authorization.policy.entity';
import { AuthorizationPolicyService } from '@domain/common/authorization-policy/authorization.policy.service';
import { Collaboration } from '@domain/collaboration/collaboration/collaboration.entity';
import { ICollaboration } from '@domain/collaboration/collaboration/collaboration.interface';
import { AgentInfo } from '@core/authentication.agent.info/agent.info';
import { CreateTagsetTemplateInput } from '@domain/common/tagset-template';
import { TagsetReservedName } from '@common/enums/tagset.reserved.name';
import { TimelineService } from '@domain/timeline/timeline/timeline.service';
import { ITimeline } from '@domain/timeline/timeline/timeline.interface';
import { IStorageAggregator } from '@domain/storage/storage-aggregator/storage.aggregator.interface';
import { InnovationFlowService } from '../innovation-flow/innovation.flow.service';
import { TagsetType } from '@common/enums/tagset.type';
import { IInnovationFlow } from '../innovation-flow/innovation.flow.interface';
import { CreateCollaborationInput } from './dto/collaboration.dto.create';
import { Space } from '@domain/space/space/space.entity';
import { SpaceLevel } from '@common/enums/space.level';
import { AuthorizationPolicyType } from '@common/enums/authorization.policy.type';
import { CreateInnovationFlowInput } from '../innovation-flow/dto/innovation.flow.dto.create';
import { LicenseService } from '@domain/common/license/license.service';
import { LicenseType } from '@common/enums/license.type';
import { LicenseEntitlementType } from '@common/enums/license.entitlement.type';
import { LicenseEntitlementDataType } from '@common/enums/license.entitlement.data.type';
import { CalloutsSetService } from '../callouts-set/callouts.set.service';
import { CalloutVisibility } from '@common/enums/callout.visibility';
import { ICalloutsSet } from '../callouts-set/callouts.set.interface';
import { CalloutsSetType } from '@common/enums/callouts.set.type';
import { sortBySortOrder } from '../innovation-flow-state/utils/sortBySortOrder';

@Injectable()
export class CollaborationService {
  constructor(
    private authorizationPolicyService: AuthorizationPolicyService,
    private calloutsSetService: CalloutsSetService,
    private innovationFlowService: InnovationFlowService,
    @InjectRepository(Collaboration)
    private collaborationRepository: Repository<Collaboration>,
    @InjectEntityManager('default')
    private entityManager: EntityManager,
    private timelineService: TimelineService,
    private licenseService: LicenseService
  ) {}

  async createCollaboration(
    collaborationData: CreateCollaborationInput,
    storageAggregator: IStorageAggregator,
    agentInfo?: AgentInfo
  ): Promise<ICollaboration> {
    if (
      !collaborationData.calloutsSetData ||
      !collaborationData.innovationFlowData
    ) {
      throw new RelationshipNotFoundException(
        'Unable to create Collaboration: missing required data',
        LogContext.COLLABORATION
      );
    }
    const collaboration: ICollaboration = Collaboration.create();
    collaboration.authorization = new AuthorizationPolicy(
      AuthorizationPolicyType.COLLABORATION
    );

    collaboration.calloutsSet = this.calloutsSetService.createCalloutsSet(
      collaborationData.calloutsSetData,
      CalloutsSetType.COLLABORATION
    );

    const innovationFlowStatesTagsetInput =
      this.createInnovationFlowStatesTagsetTemplateInput(
        collaborationData.innovationFlowData
      );
    collaboration.calloutsSet.tagsetTemplateSet =
      this.calloutsSetService.addTagsetTemplate(
        collaboration.calloutsSet,
        innovationFlowStatesTagsetInput
      );

    // save the calloutsSet with the tagsetTemplates so can use it in the innovation flow as a template for it's tags
    await this.calloutsSetService.save(collaboration.calloutsSet);

    collaboration.isTemplate = collaborationData.isTemplate || false;

    if (!collaboration.isTemplate) {
      collaboration.timeline = this.timelineService.createTimeline();
    }

    collaboration.license = this.licenseService.createLicense({
      type: LicenseType.COLLABORATION,
      entitlements: [
        {
          type: LicenseEntitlementType.SPACE_FLAG_SAVE_AS_TEMPLATE,
          dataType: LicenseEntitlementDataType.FLAG,
          limit: 0,
          enabled: false,
        },
        {
          type: LicenseEntitlementType.SPACE_FLAG_WHITEBOARD_MULTI_USER,
          dataType: LicenseEntitlementDataType.FLAG,
          limit: 0,
          enabled: false,
        },
        {
          type: LicenseEntitlementType.SPACE_FLAG_MEMO_MULTI_USER,
          dataType: LicenseEntitlementDataType.FLAG,
          limit: 0,
          enabled: false,
        },
      ],
    });

    const flowStatesTagsetTemplate = this.calloutsSetService.getTagsetTemplate(
      collaboration.calloutsSet.tagsetTemplateSet,
      TagsetReservedName.FLOW_STATE
    );

    if (!flowStatesTagsetTemplate) {
      throw new RelationshipNotFoundException(
        'Unable to create tagset template for flow states',
        LogContext.COLLABORATION
      );
    }
    // Note: need to create the innovation flow after creation of
    // tagsetTemplates on Collaboration so can pass it in to the InnovationFlow
    collaboration.innovationFlow =
      await this.innovationFlowService.createInnovationFlow(
        collaborationData.innovationFlowData,
        storageAggregator,
        flowStatesTagsetTemplate
      );

    if (collaborationData.calloutsSetData.calloutsData) {
      collaborationData.calloutsSetData.calloutsData.forEach(
        callout => (callout.isTemplate = collaboration.isTemplate)
      );
      collaboration.calloutsSet.callouts =
        await this.calloutsSetService.addCallouts(
          collaboration.calloutsSet,
          collaborationData.calloutsSetData.calloutsData,
          storageAggregator,
          agentInfo?.userID
        );
    }

    this.calloutsSetService.moveCalloutsToDefaultFlowState(
      flowStatesTagsetTemplate.allowedValues,
      collaboration.calloutsSet.callouts
    );

    return collaboration;
  }

  private createInnovationFlowStatesTagsetTemplateInput(
    innovationFlowData: CreateInnovationFlowInput
  ): CreateTagsetTemplateInput {
    this.innovationFlowService.validateInnovationFlowDefinition(
      innovationFlowData.states
    );
    const allowedValues = innovationFlowData.states
      .sort(sortBySortOrder)
      .map(state => state.displayName);
    let defaultSelectedValue = innovationFlowData.currentStateDisplayName;
    if (
      !defaultSelectedValue ||
      allowedValues.indexOf(defaultSelectedValue) === -1
    ) {
      defaultSelectedValue = allowedValues[0];
    }

    const tagsetTemplateDataStates: CreateTagsetTemplateInput = {
      name: TagsetReservedName.FLOW_STATE,
      type: TagsetType.SELECT_ONE,
      allowedValues,
      defaultSelectedValue,
    };
    return tagsetTemplateDataStates;
  }

  async save(collaboration: ICollaboration): Promise<ICollaboration> {
    return await this.collaborationRepository.save(collaboration);
  }

  async getCollaborationOrFail(
    collaborationID: string,
    options?: FindOneOptions<Collaboration>
  ): Promise<ICollaboration | never> {
    const { where, ...rest } = options ?? {};
    const collaboration = await this.collaborationRepository.findOne({
      where: {
        ...where,
        id: collaborationID,
      },
      ...rest,
    });
    if (!collaboration)
      throw new EntityNotFoundException(
        `No Collaboration found with the given id: ${collaborationID}`,
        LogContext.COLLABORATION
      );
    return collaboration;
  }

  public async getChildCollaborationsOrFail(
    collaborationID: string
  ): Promise<ICollaboration[] | never> {
    const space = await this.entityManager.findOne(Space, {
      where: { collaboration: { id: collaborationID } },
      relations: {
        subspaces: {
          collaboration: true,
        },
      },
    });
    if (!space) {
      throw new EntityNotFoundException(
        `Unable to find Space for provided collaborationID: ${collaborationID}`,
        LogContext.COLLABORATION
      );
    }

    switch (space.level) {
      case SpaceLevel.L0:
        const spacesInAccount = await this.entityManager.find(Space, {
          where: {
            levelZeroSpaceID: space.id,
          },
          relations: {
            collaboration: true,
          },
          select: {
            collaboration: {
              id: true,
            },
          },
        });
        return [...spacesInAccount].map(x => {
          if (!x.collaboration) {
            throw new EntityNotInitializedException(
              `Collaboration not found in space level ${x.level} '${x.id}'`,
              LogContext.COLLABORATION
            );
          }
          return x.collaboration;
        });
      case SpaceLevel.L1:
        const subsubspaces = space.subspaces;
        if (!subsubspaces) {
          throw new EntityNotInitializedException(
            `Subsubspaces not found on subspace with level ${space.level}`,
            LogContext.COLLABORATION
          );
        }

        return subsubspaces?.map(subsubspace => {
          if (!subsubspace.collaboration) {
            throw new EntityNotInitializedException(
              `Collaboration not found on subsubspace ${subsubspace.id}`,
              LogContext.COLLABORATION
            );
          }
          return subsubspace.collaboration;
        });
    }

    return [];
  }

  public async deleteCollaborationOrFail(
    collaborationID: string
  ): Promise<ICollaboration | never> {
    // Note need to load it in with all contained entities so can remove fully
    const collaboration = await this.getCollaborationOrFail(collaborationID, {
      relations: {
        calloutsSet: true,
        timeline: true,
        innovationFlow: true,
        authorization: true,
        license: true,
      },
    });

    if (
      !collaboration.calloutsSet ||
      !collaboration.innovationFlow ||
      !collaboration.authorization ||
      !collaboration.license
    )
      throw new RelationshipNotFoundException(
        `Unable to remove Collaboration: missing child entities ${collaboration.id} `,
        LogContext.SPACE_ABOUT
      );

    await this.calloutsSetService.deleteCalloutsSet(
      collaboration.calloutsSet.id
    );

    if (collaboration.timeline) {
      // There's no timeline for collaboration templates
      await this.timelineService.deleteTimeline(collaboration.timeline.id);
    }

    await this.authorizationPolicyService.delete(collaboration.authorization);

    await this.innovationFlowService.deleteInnovationFlow(
      collaboration.innovationFlow.id
    );
    await this.licenseService.removeLicenseOrFail(collaboration.license.id);

    return await this.collaborationRepository.remove(
      collaboration as Collaboration
    );
  }

  async getTimelineOrFail(collaborationID: string): Promise<ITimeline> {
    const collaboration = await this.getCollaborationOrFail(collaborationID, {
      relations: { timeline: true },
    });
    const timeline = collaboration.timeline;

    if (!timeline) {
      throw new EntityNotFoundException(
        `Unable to find timeline for collaboration: ${collaboration.id}`,
        LogContext.COLLABORATION
      );
    }

    return timeline;
  }

  async getInnovationFlow(collaborationID: string): Promise<IInnovationFlow> {
    const collaboration = await this.getCollaborationOrFail(collaborationID, {
      relations: {
        innovationFlow: true,
      },
    });

    const innovationFlow = collaboration.innovationFlow;
    if (!innovationFlow)
      throw new RelationshipNotFoundException(
        `Unable to load InnovationFlow for Collaboration ${collaborationID} `,
        LogContext.SPACES
      );

    return innovationFlow;
  }

  public async getPostsCount(calloutsSet: ICalloutsSet): Promise<number> {
    const [result]: {
      postsCount: number;
    }[] = await this.entityManager.connection.query(
      `
      SELECT COUNT(*) as postsCount FROM \`callouts_set\`
      RIGHT JOIN \`callout\` ON \`callout\`.\`calloutsSetId\` = \`callouts_set\`.\`id\`
      RIGHT JOIN \`callout_contribution\` ON \`callout_contribution\`.\`calloutId\` = \`callout\`.\`id\`
      WHERE \`callouts_set\`.\`id\` = '${calloutsSet.id}'
        AND \`callout\`.\`visibility\` = '${CalloutVisibility.PUBLISHED}'
        AND NOT(ISNULL(\`callout_contribution\`.\`postId\`));
      `
    );

    return result.postsCount;
  }

  public async getWhiteboardsCount(calloutsSet: ICalloutsSet): Promise<number> {
    const [result]: {
      whiteboardsCount: number;
    }[] = await this.entityManager.connection.query(
      `
      SELECT COUNT(*) as whiteboardsCount
      FROM \`callouts_set\` RIGHT JOIN \`callout\` ON \`callout\`.\`calloutsSetId\` = \`callouts_set\`.\`id\`
      RIGHT JOIN \`callout_contribution\` ON \`callout_contribution\`.\`calloutId\` = \`callout\`.\`id\`
      WHERE \`callouts_set\`.\`id\` = '${calloutsSet.id}'
        AND \`callout\`.\`visibility\` = '${CalloutVisibility.PUBLISHED}'
        AND NOT(ISNULL(\`callout_contribution\`.\`whiteboardId\`));
      `
    );

    return result.whiteboardsCount;
  }
}

1	import { Injectable } from '@nestjs/common';	17✔
2	import { InjectEntityManager, InjectRepository } from '@nestjs/typeorm';	17✔
3	import { EntityManager, FindOneOptions, Repository } from 'typeorm';	17✔
4	import {
5	EntityNotFoundException,
6	EntityNotInitializedException,
7	RelationshipNotFoundException,
8	} from '@common/exceptions';
9	import { LogContext } from '@common/enums';
10	import { AuthorizationPolicy } from '@domain/common/authorization-policy/authorization.policy.entity';	17✔
11	import { AuthorizationPolicyService } from '@domain/common/authorization-policy/authorization.policy.service';
12	import { Collaboration } from '@domain/collaboration/collaboration/collaboration.entity';
13	import { ICollaboration } from '@domain/collaboration/collaboration/collaboration.interface';
14	import { AgentInfo } from '@core/authentication.agent.info/agent.info';
15	import { CreateTagsetTemplateInput } from '@domain/common/tagset-template';
16	import { TagsetReservedName } from '@common/enums/tagset.reserved.name';
17	import { TimelineService } from '@domain/timeline/timeline/timeline.service';	17✔
18	import { ITimeline } from '@domain/timeline/timeline/timeline.interface';	17✔
19	import { IStorageAggregator } from '@domain/storage/storage-aggregator/storage.aggregator.interface';	17✔
20	import { InnovationFlowService } from '../innovation-flow/innovation.flow.service';
21	import { TagsetType } from '@common/enums/tagset.type';	17✔
22	import { IInnovationFlow } from '../innovation-flow/innovation.flow.interface';	17✔
23	import { CreateCollaborationInput } from './dto/collaboration.dto.create';
24	import { Space } from '@domain/space/space/space.entity';	17✔
25	import { SpaceLevel } from '@common/enums/space.level';
26	import { AuthorizationPolicyType } from '@common/enums/authorization.policy.type';	17✔
27	import { CreateInnovationFlowInput } from '../innovation-flow/dto/innovation.flow.dto.create';	17✔
28	import { LicenseService } from '@domain/common/license/license.service';	17✔
29	import { LicenseType } from '@common/enums/license.type';
30	import { LicenseEntitlementType } from '@common/enums/license.entitlement.type';
31	import { LicenseEntitlementDataType } from '@common/enums/license.entitlement.data.type';
32	import { CalloutsSetService } from '../callouts-set/callouts.set.service';	17✔
33	import { CalloutVisibility } from '@common/enums/callout.visibility';
34	import { ICalloutsSet } from '../callouts-set/callouts.set.interface';	17✔
35	import { CalloutsSetType } from '@common/enums/callouts.set.type';
36	import { sortBySortOrder } from '../innovation-flow-state/utils/sortBySortOrder';
37
38	@Injectable()
39	export class CollaborationService {
40	constructor(
41	private authorizationPolicyService: AuthorizationPolicyService,	17✔
42	private calloutsSetService: CalloutsSetService,	17✔
43	private innovationFlowService: InnovationFlowService,
44	@InjectRepository(Collaboration)	17✔
45	private collaborationRepository: Repository<Collaboration>,
46	@InjectEntityManager('default')	17✔
47	private entityManager: EntityManager,	17✔
48	private timelineService: TimelineService,	17✔
49	private licenseService: LicenseService	17✔
50	) {}	17✔
51
52	async createCollaboration(
53	collaborationData: CreateCollaborationInput,	17✔
54	storageAggregator: IStorageAggregator,
55	agentInfo?: AgentInfo	17✔
56	): Promise<ICollaboration> {
57	if (
58	!collaborationData.calloutsSetData \|\|
59	!collaborationData.innovationFlowData	17✔
60	) {
61	throw new RelationshipNotFoundException(	17✔
62	'Unable to create Collaboration: missing required data',
63	LogContext.COLLABORATION
64	);	17✔
65	}
66	const collaboration: ICollaboration = Collaboration.create();	×
67	collaboration.authorization = new AuthorizationPolicy(	×
68	AuthorizationPolicyType.COLLABORATION	×
69	);	×
70		×
71	collaboration.calloutsSet = this.calloutsSetService.createCalloutsSet(	×
72	collaborationData.calloutsSetData,	×
73	CalloutsSetType.COLLABORATION
74	);	×
75
76	const innovationFlowStatesTagsetInput =	×
77	this.createInnovationFlowStatesTagsetTemplateInput(	×
78	collaborationData.innovationFlowData	×
79	);	×
80	collaboration.calloutsSet.tagsetTemplateSet =
81	this.calloutsSetService.addTagsetTemplate(
82	collaboration.calloutsSet,
83	innovationFlowStatesTagsetInput
84	);
85
86	// save the calloutsSet with the tagsetTemplates so can use it in the innovation flow as a template for it's tags
87	await this.calloutsSetService.save(collaboration.calloutsSet);
88		×
NEW 89	collaboration.isTemplate = collaborationData.isTemplate \|\| false;	×
90
91	if (!collaboration.isTemplate) {
92	collaboration.timeline = this.timelineService.createTimeline();	×
93	}	×
94		×
95	collaboration.license = this.licenseService.createLicense({	×
96	type: LicenseType.COLLABORATION,
97	entitlements: [
98	{	×
99	type: LicenseEntitlementType.SPACE_FLAG_SAVE_AS_TEMPLATE,
100	dataType: LicenseEntitlementDataType.FLAG,
101	limit: 0,
102	enabled: false,
103	},	×
104	{
105	type: LicenseEntitlementType.SPACE_FLAG_WHITEBOARD_MULTI_USER,
106	dataType: LicenseEntitlementDataType.FLAG,
107	limit: 0,
108	enabled: false,	×
109	},	×
110	{
111	type: LicenseEntitlementType.SPACE_FLAG_MEMO_MULTI_USER,
112	dataType: LicenseEntitlementDataType.FLAG,	×
113	limit: 0,
114	enabled: false,
115	},
116	],
117	});	×
118
119	const flowStatesTagsetTemplate = this.calloutsSetService.getTagsetTemplate(
120	collaboration.calloutsSet.tagsetTemplateSet,	×
121	TagsetReservedName.FLOW_STATE
122	);
123
124	if (!flowStatesTagsetTemplate) {
125	throw new RelationshipNotFoundException(
126	'Unable to create tagset template for flow states',
127	LogContext.COLLABORATION	×
128	);
129	}
130	// Note: need to create the innovation flow after creation of
131	// tagsetTemplates on Collaboration so can pass it in to the InnovationFlow
132	collaboration.innovationFlow =
133	await this.innovationFlowService.createInnovationFlow(
134	collaborationData.innovationFlowData,	×
135	storageAggregator,
136	flowStatesTagsetTemplate
137	);
138		×
139	if (collaborationData.calloutsSetData.calloutsData) {
140	collaborationData.calloutsSetData.calloutsData.forEach(
141	callout => (callout.isTemplate = collaboration.isTemplate)
142	);
143	collaboration.calloutsSet.callouts =
144	await this.calloutsSetService.addCallouts(
145	collaboration.calloutsSet,	×
146	collaborationData.calloutsSetData.calloutsData,
147	storageAggregator,
148	agentInfo?.userID
149	);
150	}
151		×
152	this.calloutsSetService.moveCalloutsToDefaultFlowState(
153	flowStatesTagsetTemplate.allowedValues,
154	collaboration.calloutsSet.callouts
155	);
156
157	return collaboration;
158	}	×
159		×
160	private createInnovationFlowStatesTagsetTemplateInput(
161	innovationFlowData: CreateInnovationFlowInput
162	): CreateTagsetTemplateInput {
163	this.innovationFlowService.validateInnovationFlowDefinition(
164	innovationFlowData.states	×
165	);
166	const allowedValues = innovationFlowData.states
167	.sort(sortBySortOrder)
168	.map(state => state.displayName);	×
169	let defaultSelectedValue = innovationFlowData.currentStateDisplayName;	×
170	if (
171	!defaultSelectedValue \|\|
172	allowedValues.indexOf(defaultSelectedValue) === -1
173	) {
174	defaultSelectedValue = allowedValues[0];
175	}
176
177	const tagsetTemplateDataStates: CreateTagsetTemplateInput = {
178	name: TagsetReservedName.FLOW_STATE,	×
179	type: TagsetType.SELECT_ONE,
180	allowedValues,
181	defaultSelectedValue,	×
182	};
183	return tagsetTemplateDataStates;
184	}	×
185		×
186	async save(collaboration: ICollaboration): Promise<ICollaboration> {
187	return await this.collaborationRepository.save(collaboration);
188	}
189
190	async getCollaborationOrFail(
191	collaborationID: string,
192	options?: FindOneOptions<Collaboration>	×
193	): Promise<ICollaboration \| never> {	×
194	const { where, ...rest } = options ?? {};
195	const collaboration = await this.collaborationRepository.findOne({	×
196	where: {
197	...where,
198	id: collaborationID,
199	},
200	...rest,
201	});	×
202	if (!collaboration)
203	throw new EntityNotFoundException(
204	`No Collaboration found with the given id: ${collaborationID}`,
205	LogContext.COLLABORATION
206	);
207	return collaboration;
208	}
209
210	public async getChildCollaborationsOrFail(
211	collaborationID: string
212	): Promise<ICollaboration[] \| never> {
213	const space = await this.entityManager.findOne(Space, {
214	where: { collaboration: { id: collaborationID } },
215	relations: {
216	subspaces: {
217	collaboration: true,
218	},
219	},
220	});
221	if (!space) {	×
222	throw new EntityNotFoundException(
223	`Unable to find Space for provided collaborationID: ${collaborationID}`,
224	LogContext.COLLABORATION
225	);
226	}
227		×
228	switch (space.level) {
229	case SpaceLevel.L0:
230	const spacesInAccount = await this.entityManager.find(Space, {
231	where: {
232	levelZeroSpaceID: space.id,
233	},
234	relations: {	×
235	collaboration: true,	×
236	},
237	select: {
238	collaboration: {
239	id: true,
240	},
241	},
242	});	×
243	return [...spacesInAccount].map(x => {	×
244	if (!x.collaboration) {
245	throw new EntityNotInitializedException(
246	`Collaboration not found in space level ${x.level} '${x.id}'`,
247	LogContext.COLLABORATION	×
248	);
249	}
250	return x.collaboration;
251	});
252	case SpaceLevel.L1:
253	const subsubspaces = space.subspaces;	×
254	if (!subsubspaces) {	×
255	throw new EntityNotInitializedException(
256	`Subsubspaces not found on subspace with level ${space.level}`,
257	LogContext.COLLABORATION	×
258	);
259	}	×
260
261	return subsubspaces?.map(subsubspace => {
262	if (!subsubspace.collaboration) {
263	throw new EntityNotInitializedException(
264	`Collaboration not found on subsubspace ${subsubspace.id}`,
265	LogContext.COLLABORATION	×
266	);
267	}
268	return subsubspace.collaboration;
269	});
270	}
271
272	return [];
273	}	×
274		×
275	public async deleteCollaborationOrFail(
276	collaborationID: string
277	): Promise<ICollaboration \| never> {
278	// Note need to load it in with all contained entities so can remove fully
279	const collaboration = await this.getCollaborationOrFail(collaborationID, {
280	relations: {	×
281	calloutsSet: true,
282	timeline: true,	×
283	innovationFlow: true,
284	authorization: true,
285	license: true,
286	},
287	});
288
289	if (
290	!collaboration.calloutsSet \|\|
291	!collaboration.innovationFlow \|\|
292	!collaboration.authorization \|\|
293	!collaboration.license
294	)
295	throw new RelationshipNotFoundException(	×
296	`Unable to remove Collaboration: missing child entities ${collaboration.id} `,	×
297	LogContext.SPACE_ABOUT	×
298	);
299
300	await this.calloutsSetService.deleteCalloutsSet(
301	collaboration.calloutsSet.id
302	);	×
303
304	if (collaboration.timeline) {
305	// There's no timeline for collaboration templates	×
306	await this.timelineService.deleteTimeline(collaboration.timeline.id);	×
307	}	×
308
309	await this.authorizationPolicyService.delete(collaboration.authorization);
310
311	await this.innovationFlowService.deleteInnovationFlow(
312	collaboration.innovationFlow.id
313	);	×
314	await this.licenseService.removeLicenseOrFail(collaboration.license.id);	×
315		×
316	return await this.collaborationRepository.remove(
317	collaboration as Collaboration
318	);
319	}
320		×
321	async getTimelineOrFail(collaborationID: string): Promise<ITimeline> {
322	const collaboration = await this.getCollaborationOrFail(collaborationID, {
323	relations: { timeline: true },
324	});	×
325	const timeline = collaboration.timeline;
326
327	if (!timeline) {
328	throw new EntityNotFoundException(
329	`Unable to find timeline for collaboration: ${collaboration.id}`,
330	LogContext.COLLABORATION
331	);	×
332	}
333
334	return timeline;
335	}
336
337	async getInnovationFlow(collaborationID: string): Promise<IInnovationFlow> {
338	const collaboration = await this.getCollaborationOrFail(collaborationID, {
339	relations: {
340	innovationFlow: true,	×
341	},	×
342	});
343
344	const innovationFlow = collaboration.innovationFlow;
345	if (!innovationFlow)
346	throw new RelationshipNotFoundException(	×
347	`Unable to load InnovationFlow for Collaboration ${collaborationID} `,
348	LogContext.SPACES
349	);
350
351	return innovationFlow;	×
352	}	×
353
354	public async getPostsCount(calloutsSet: ICalloutsSet): Promise<number> {
355	const [result]: {	×
356	postsCount: number;
357	}[] = await this.entityManager.connection.query(	×
358	`
359	SELECT COUNT(*) as postsCount FROM \`callouts_set\`	×
360	RIGHT JOIN \`callout\` ON \`callout\`.\`calloutsSetId\` = \`callouts_set\`.\`id\`
361	RIGHT JOIN \`callout_contribution\` ON \`callout_contribution\`.\`calloutId\` = \`callout\`.\`id\`
362	WHERE \`callouts_set\`.\`id\` = '${calloutsSet.id}'
363	AND \`callout\`.\`visibility\` = '${CalloutVisibility.PUBLISHED}'	×
364	AND NOT(ISNULL(\`callout_contribution\`.\`postId\`));
365	`
366	);
367
368	return result.postsCount;
369	}	×
370
371	public async getWhiteboardsCount(calloutsSet: ICalloutsSet): Promise<number> {
372	const [result]: {
373	whiteboardsCount: number;
374	}[] = await this.entityManager.connection.query(
375	`
376	SELECT COUNT(*) as whiteboardsCount	×
377	FROM \`callouts_set\` RIGHT JOIN \`callout\` ON \`callout\`.\`calloutsSetId\` = \`callouts_set\`.\`id\`	×
378	RIGHT JOIN \`callout_contribution\` ON \`callout_contribution\`.\`calloutId\` = \`callout\`.\`id\`
379	WHERE \`callouts_set\`.\`id\` = '${calloutsSet.id}'
380	AND \`callout\`.\`visibility\` = '${CalloutVisibility.PUBLISHED}'	×
381	AND NOT(ISNULL(\`callout_contribution\`.\`whiteboardId\`));	×
382	`
383	);
384
385	return result.whiteboardsCount;	×
386	}	×
387	}

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