Reupload

server/src/core/features/metrics/MetricsUseCases.ts

@@ -0,0 +1,84 @@
+import {LimitReached} from "@app/core/exceptions/LimitReached";
+import {MissingResource} from "../projects/exceptions/MissingResource";
+import {ProjectAuthorization, ProjectContext} from "../projects/ProjectContext";
+import {ProjectsUseCases} from "../projects/ProjectsUseCases";
+import {getMetricsHistoryLimit} from "../users/utils";
+import {Metric, MetricCreationProperties} from "./entities";
+import {MetricEvents} from "./MetricsEvents";
+import {MetricsRepository} from "./MetricsRepository";
+
+interface MetricServiceDependencies {
+	projectService: ProjectsUseCases,
+	metricRepository: MetricsRepository,
+	metricEvents: MetricEvents
+}
+
+export class MetricsUseCases {
+	private _projectService: ProjectsUseCases
+	private _metricRepository: MetricsRepository
+	private _metricEvents: MetricEvents
+
+	constructor(dependencies: MetricServiceDependencies) {
+		this._projectService = dependencies.projectService
+		this._metricRepository = dependencies.metricRepository
+		this._metricEvents = dependencies.metricEvents
+	}
+
+	async createMetric(context: ProjectContext, metricInfo: MetricCreationProperties): Promise<Metric> {
+		context.enforceAuthorizations([ProjectAuthorization.Write])
+		const {project, caller} = context;
+		
+		const metric = await this._metricRepository.createMetric(project, metricInfo.name)
+		await this._metricEvents.onMetricCreated.emit({project, metric: metric, caller});
+		return metric
+	}
+
+	async updateMetric(context: ProjectContext, metric: Metric, metricInfo: MetricCreationProperties): Promise<void> {
+		context.enforceAuthorizations([ProjectAuthorization.Write])
+		await this._metricRepository.updateMetric(metric, metricInfo.name)
+	}
+
+	async getAllMetrics(context: ProjectContext, fetchValues?: boolean): Promise<Metric[]> {
+		context.enforceAuthorizations([ProjectAuthorization.Read])
+		
+		const metric = await this._metricRepository.findAll(context.project, fetchValues);
+		return metric
+	}
+
+	async getMetricById(context: ProjectContext, metricId: string, fetchValues?: boolean): Promise<Metric> {
+		context.enforceAuthorizations([ProjectAuthorization.Read])
+		
+		const metric = await this._metricRepository.findMetricById(context.project, metricId, fetchValues);
+		if (!metric) {
+			throw new MissingResource("Metric doesn't exist")
+		}
+		return metric
+	}
+
+	async deleteMetric(context: ProjectContext, metric: Metric): Promise<void> {
+		context.enforceAuthorizations([ProjectAuthorization.Write])
+		
+		await this._metricRepository.deleteMetric(metric);
+	}
+
+	async deleteMetricHistoryRecord(context: ProjectContext, metric: Metric, recordId: string): Promise<void> {
+		context.enforceAuthorizations([ProjectAuthorization.Write])
+		
+		await this._metricRepository.deleteHistoryRecord(metric, recordId);
+	}
+
+	async setMetricValue(context: ProjectContext, metric: Metric, value: number, date?: number) {
+		context.enforceAuthorizations([ProjectAuthorization.Write])
+		
+		const currentHistoryLength = await this._metricRepository.getHistoryLengthOfMetric(metric)
+
+		if (currentHistoryLength >= getMetricsHistoryLimit()) {
+			throw new LimitReached("History limit reached (experimental feature)")
+		}
+
+		await this._metricRepository.AddValueToHistory(metric, {
+			date: date || Date.now(),
+			value
+		})
+	}
+}