metis-desk/modules/companies/src/api/module.ts

import type { IResourceInventoryService } from "@metis/resources/services";
import type { RequestHandler } from "express";
import type { Sequelize } from "sequelize";

import { AccessUseCases } from "./application/access.use-cases";
import { ApplicationConfigurationUseCases } from "./application/application-configuration.use-cases";
import { CertificateConfigurationUseCases } from "./application/certificate-configuration.use-cases";
import { CompanyUseCases } from "./application/company.use-cases";
import { CompanyInputMapper } from "./application/company-input.mapper";
import { CompanyLogoUseCases } from "./application/company-logo.use-cases";
import type {
  IAssetDashboardReader,
  IInventoryDashboardReader,
} from "./application/dashboard.use-cases";
import { DashboardUseCases } from "./application/dashboard.use-cases";
import { FolderMappingUseCases } from "./application/folder-mapping.use-cases";
import { InterventionUseCases } from "./application/intervention.use-cases";
import { InterventionTemplateUseCases } from "./application/intervention-template.use-cases";
import type { IMailInventoryService } from "./application/mail-configuration.repository";
import { MailConfigurationUseCases } from "./application/mail-configuration.use-cases";
import { MailboxUseCases } from "./application/mailbox.use-cases";
import { PrinterConfigurationUseCases } from "./application/printer-configuration.use-cases";
import type { IProcessAssetInventoryService } from "./application/process.repository";
import { ProcessUseCases } from "./application/process.use-cases";
import { RemoteConnectionUseCases } from "./application/remote-connection.use-cases";
import { TeleworkAuthorizationUseCases } from "./application/telework-authorization.use-cases";
import type { ITicketInventoryService } from "./application/ticket.repository";
import { TicketUseCases } from "./application/ticket.use-cases";
import type { IWorkProfileInventoryService } from "./application/work-profile.repository";
import { WorkProfileUseCases } from "./application/work-profile.use-cases";
import { CompanyLogoProcessor } from "./infrastructure/company-logo-processor";
import { registerAccessRoutes } from "./infrastructure/http/access.routes";
import { registerApplicationConfigurationRoutes } from "./infrastructure/http/application-configuration.routes";
import { registerCertificateConfigurationRoutes } from "./infrastructure/http/certificate-configuration.routes";
import { registerCompanyRoutes } from "./infrastructure/http/company.routes";
import { registerCompanyLogoRoutes } from "./infrastructure/http/company-logo.routes";
import { registerDashboardRoutes } from "./infrastructure/http/dashboard.routes";
import { registerFolderMappingRoutes } from "./infrastructure/http/folder-mapping.routes";
import { registerInterventionRoutes } from "./infrastructure/http/intervention.routes";
import { registerInterventionTemplateRoutes } from "./infrastructure/http/intervention-template.routes";
import { registerMailRoutes } from "./infrastructure/http/mail-configuration.routes";
import { registerMailboxRoutes } from "./infrastructure/http/mailbox.routes";
import { registerPrinterConfigurationRoutes } from "./infrastructure/http/printer-configuration.routes";
import { registerProcessRoutes } from "./infrastructure/http/process.routes";
import { registerRemoteConnectionRoutes } from "./infrastructure/http/remote-connection.routes";
import { registerTeleworkAuthorizationRoutes } from "./infrastructure/http/telework-authorization.routes";
import { registerTicketRoutes } from "./infrastructure/http/ticket.routes";
import { registerWorkProfileRoutes } from "./infrastructure/http/work-profile.routes";
import {
  AccessPersistenceMapper,
  SequelizeAccessRepository,
  migrateAccess,
} from "./infrastructure/persistence/access-persistence";
import { migrateApplicationConfigurations } from "./infrastructure/persistence/application-configuration-migration";
import { migrateCertificateConfigurations } from "./infrastructure/persistence/certificate-configuration-migration";
import { initializeCompanyModels } from "./infrastructure/persistence/company.model";
import { migrateCompanyLogos } from "./infrastructure/persistence/company-logo-migration";
import { CompanyPersistenceMapper } from "./infrastructure/persistence/company-persistence.mapper";
import { migrateFolderMappings } from "./infrastructure/persistence/folder-mapping-migration";
import { migrateInterventions } from "./infrastructure/persistence/intervention-migration";
import { migrateInterventionTemplates } from "./infrastructure/persistence/intervention-template-migration";
import { migrateMailConfigurations } from "./infrastructure/persistence/mail-configuration-migration";
import { migrateMailboxes } from "./infrastructure/persistence/mailbox-migration";
import { migrateCompanies } from "./infrastructure/persistence/migrate-companies";
import { migratePeople } from "./infrastructure/persistence/migrate-people";
import { initializePeopleModels } from "./infrastructure/persistence/people.model";
import { migratePrinterConfigurations } from "./infrastructure/persistence/printer-configuration-migration";
import { migrateProcesses } from "./infrastructure/persistence/process-migration";
import { migrateRemoteConnections } from "./infrastructure/persistence/remote-connection-migration";
import { SequelizeApplicationConfigurationRepository } from "./infrastructure/persistence/sequelize-application-configuration.repository";
import { SequelizeCertificateConfigurationRepository } from "./infrastructure/persistence/sequelize-certificate-configuration.repository";
import { SequelizeCompanyRepository } from "./infrastructure/persistence/sequelize-company.repository";
import { SequelizeCompanyLogoRepository } from "./infrastructure/persistence/sequelize-company-logo.repository";
import { SequelizeDashboardRepository } from "./infrastructure/persistence/sequelize-dashboard.repository";
import { SequelizeFolderMappingRepository } from "./infrastructure/persistence/sequelize-folder-mapping.repository";
import { SequelizeInterventionRepository } from "./infrastructure/persistence/sequelize-intervention.repository";
import { SequelizeInterventionTemplateRepository } from "./infrastructure/persistence/sequelize-intervention-template.repository";
import { SequelizeMailConfigurationRepository } from "./infrastructure/persistence/sequelize-mail-configuration.repository";
import { SequelizeMailboxRepository } from "./infrastructure/persistence/sequelize-mailbox.repository";
import { SequelizePrinterConfigurationRepository } from "./infrastructure/persistence/sequelize-printer-configuration.repository";
import { SequelizeProcessRepository } from "./infrastructure/persistence/sequelize-process.repository";
import { SequelizeRemoteConnectionRepository } from "./infrastructure/persistence/sequelize-remote-connection.repository";
import { SequelizeTeleworkAuthorizationRepository } from "./infrastructure/persistence/sequelize-telework-authorization.repository";
import { SequelizeTicketRepository } from "./infrastructure/persistence/sequelize-ticket.repository";
import { SequelizeWorkProfileRepository } from "./infrastructure/persistence/sequelize-work-profile.repository";
import { migrateTeleworkAuthorizations } from "./infrastructure/persistence/telework-authorization-migration";
import { migrateTickets } from "./infrastructure/persistence/ticket-migration";
import { migrateWorkProfiles } from "./infrastructure/persistence/work-profile-migration";

export async function createCompanyModule(
  database: Sequelize,
  authenticate: RequestHandler,
  legacyResourceWrites = false
) {
  await migrateCompanies(database);
  await migrateCompanyLogos(database);
  await migratePeople(database);
  await migrateInterventionTemplates(database);
  const interventionTemplateRepository = new SequelizeInterventionTemplateRepository(database);
  const interventionTemplates = new InterventionTemplateUseCases(interventionTemplateRepository);
  initializeCompanyModels(database);
  initializePeopleModels(database);
  const repository = new SequelizeCompanyRepository(database, new CompanyPersistenceMapper());
  await migrateTeleworkAuthorizations(database);
  const telework = new TeleworkAuthorizationUseCases(
    new SequelizeTeleworkAuthorizationRepository(database)
  );
  await migrateAccess(database);
  const access = new AccessUseCases(
    new SequelizeAccessRepository(database, repository, new AccessPersistenceMapper())
  );
  const useCases = new CompanyUseCases(repository, new CompanyInputMapper());
  const logos = new CompanyLogoUseCases(
    new SequelizeCompanyLogoRepository(database),
    new CompanyLogoProcessor()
  );
  return {
    initializeDashboard: (assets: IAssetDashboardReader, resources: IInventoryDashboardReader) => {
      const dashboard = new DashboardUseCases(
        new SequelizeDashboardRepository(database, assets, resources)
      );
      return {
        register: (app: Parameters<typeof registerDashboardRoutes>[0]) =>
          registerDashboardRoutes(app, dashboard, authenticate),
      };
    },
    initializeProfiles: async (
      inventory: IWorkProfileInventoryService &
        IProcessAssetInventoryService &
        ITicketInventoryService,
      resources: IResourceInventoryService
    ) => {
      await migrateTickets(database);
      const ticketRepository = new SequelizeTicketRepository(database, inventory, resources);
      const tickets = new TicketUseCases(ticketRepository);
      await migrateInterventions(database);
      const interventions = new InterventionUseCases(
        new SequelizeInterventionRepository(
          database,
          ticketRepository,
          interventionTemplateRepository
        )
      );
      await migrateProcesses(database);
      const processes = new ProcessUseCases(
        new SequelizeProcessRepository(database, inventory, resources)
      );
      await migrateRemoteConnections(database);
      const remote = new RemoteConnectionUseCases(
        new SequelizeRemoteConnectionRepository(database, inventory, resources)
      );
      await migrateWorkProfiles(database);
      await migrateFolderMappings(database);
      await migratePrinterConfigurations(database);
      await migrateApplicationConfigurations(database);
      await migrateCertificateConfigurations(database);
      const certificates = new CertificateConfigurationUseCases(
        new SequelizeCertificateConfigurationRepository(database, inventory, resources)
      );
      const applications = new ApplicationConfigurationUseCases(
        new SequelizeApplicationConfigurationRepository(database, inventory, resources)
      );
      const printers = new PrinterConfigurationUseCases(
        new SequelizePrinterConfigurationRepository(database, inventory)
      );
      const folders = new FolderMappingUseCases(
        new SequelizeFolderMappingRepository(database, inventory)
      );
      const profiles = new WorkProfileUseCases(
        new SequelizeWorkProfileRepository(database, inventory)
      );
      return {
        register: (app: Parameters<typeof registerWorkProfileRoutes>[0]) => {
          registerInterventionRoutes(app, interventions, authenticate);
          registerTicketRoutes(app, tickets, authenticate);
          registerProcessRoutes(app, processes, authenticate);
          registerRemoteConnectionRoutes(app, remote, authenticate);
          registerWorkProfileRoutes(app, profiles, authenticate);
          registerFolderMappingRoutes(app, folders, authenticate);
          registerPrinterConfigurationRoutes(app, printers, authenticate);
          registerApplicationConfigurationRoutes(app, applications, authenticate);
          registerCertificateConfigurationRoutes(app, certificates, authenticate);
        },
      };
    },
    initializeMail: async (inventory: IMailInventoryService) => {
      await migrateWorkProfiles(database);
      await migrateMailboxes(database);
      await migrateMailConfigurations(database);
      const mailboxRepository = new SequelizeMailboxRepository(database);
      const mailboxes = new MailboxUseCases(mailboxRepository);
      const mail = new MailConfigurationUseCases(
        new SequelizeMailConfigurationRepository(database, inventory, mailboxRepository)
      );
      return {
        register: (app: Parameters<typeof registerMailRoutes>[0]) => {
          registerMailRoutes(app, mail, authenticate);
          registerMailboxRoutes(app, mailboxes, authenticate, legacyResourceWrites);
        },
      };
    },
    register: (app: Parameters<typeof registerCompanyRoutes>[0]) => {
      registerInterventionTemplateRoutes(app, interventionTemplates, authenticate);
      registerCompanyLogoRoutes(app, logos, authenticate);
      registerCompanyRoutes(app, useCases, authenticate);
      registerTeleworkAuthorizationRoutes(app, telework, authenticate);
      registerAccessRoutes(app, access, authenticate, legacyResourceWrites);
    },
  };
}