All files / libs/payout-calculation/compute-engine/core-engine/src calculations.tasks.ts

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
import { type INestApplicationContext } from '@nestjs/common';

import { type StatementReviewedEvent } from '@amalia/core/models';
import {
  type ExecutePlanTemplateBuildEvent,
  type ScheduleCalculationEvent,
  type StatementDatasetCacheBurstEvent,
} from '@amalia/core/types';
import {
  MessageTasks,
  type CalculationPayload,
  type ExtractMetricsPayload,
  type PaymentReleasePayload,
  type QueueMessageAttributes,
  type QueueMessageContent,
  type ResumeCalculationPayload,
} from '@amalia/kernel/queue/core';
import {
  CreateCalculationUseCase,
  ResumeCalculationsHandler,
  ScheduleCalculationsHandler,
} from '@amalia/payout-calculation/compute-engine/core-lifecycle';
import { BuildAndSavePlanTemplateUseCase } from '@amalia/payout-calculation/compute-engine/core-plan-template';

import { PaymentReleaseHandler } from './engine/handlers/paymentRelease.handler';
import { SchedulePaymentReleaseHandler } from './engine/handlers/schedulePaymentRelease.handler';
import { StatementSaveDatasetService } from './engine/statementSave/datasets/statementSaveDataset.service';
import { StatementMetricsFullReindexHandler } from './engine/statementSave/metrics/reindex/statementMetricsFullReindex.handler';
import { StatementsMetricsService } from './engine/statementSave/metrics/statementMetrics.service';
import { StatementSaveModule } from './engine/statementSave/statementSave.module';
import { StatementSaveService } from './engine/statementSave/statementSave.service';
import { RunCalculationBatchUseCase } from './engine/usecases/RunCalculationBatch.use-case';

export const executeCalculationsTasks = async (
  app: INestApplicationContext,
  attributes: QueueMessageAttributes<MessageTasks>,
  messageContent: QueueMessageContent,
) => {
  switch (attributes.taskIdentifier) {
    case MessageTasks.SCHEDULE_CALCULATION: {
      await app.get(CreateCalculationUseCase).execute(messageContent as { calculationEvent: ScheduleCalculationEvent });
      break;
    }

    case MessageTasks.RESUME_CALCULATION: {
      await app.get(ResumeCalculationsHandler).handle(messageContent as ResumeCalculationPayload);
      break;
    }

    // Used for nightly calculations
    case MessageTasks.SCHEDULE_CALCULATION_BATCH: {
      await app.get(ScheduleCalculationsHandler).handle((messageContent as { batchNumber: number }).batchNumber);
      break;
    }

    case MessageTasks.EXECUTE_CALCULATIONS: {
      await app.get(RunCalculationBatchUseCase).handle(messageContent as CalculationPayload);
      break;
    }

    case MessageTasks.RELEASE_PAYMENTS: {
      await app.get(PaymentReleaseHandler).handle(messageContent as PaymentReleasePayload);
      break;
    }

    case MessageTasks.SCHEDULE_RELEASE_PAYMENTS: {
      await app.get(SchedulePaymentReleaseHandler).handle();
      break;
    }

    case MessageTasks.DELETE_STATEMENTS_BEFORE_CALCULATION: {
      const { companyId, statementIds } = messageContent as { companyId: string; statementIds: string[] };
      await app.select(StatementSaveModule).get(StatementSaveService).deleteStatements(companyId, statementIds);
      break;
    }

    case MessageTasks.EXECUTE_PLAN_TEMPLATE_BUILD: {
      await app
        .get(BuildAndSavePlanTemplateUseCase)
        .execute((messageContent as { planTemplateBuildEvent: ExecutePlanTemplateBuildEvent }).planTemplateBuildEvent);
      break;
    }

    case MessageTasks.BURST_STATEMENT_DATASET_CACHE: {
      await app
        .get(StatementSaveDatasetService)
        .handleBurstDatasetCacheEvent(messageContent as StatementDatasetCacheBurstEvent);
      break;
    }

    case MessageTasks.STATEMENT_REVIEWED: {
      const {
        companyId,
        statementId,
        to: { isReviewed },
      } = messageContent as StatementReviewedEvent;
      await app.get(StatementsMetricsService).reviewMetricsForStatement(companyId, statementId, isReviewed);
      break;
    }

    case MessageTasks.EXTRACT_METRICS_FOR_COMPANIES:
      await app
        .select(StatementSaveModule)
        .get(StatementMetricsFullReindexHandler)
        .handle(messageContent as ExtractMetricsPayload);
      break;

    // Will not handle any tasks.
    default:
      return false;
  }

  // Task has been handled.
  return true;
};