"use strict";

Object.defineProperty(exports, "__esModule", {
  value: true
});
exports.sloRouteRepository = void 0;
var _elasticsearch = require("@elastic/elasticsearch");
var _boom = require("@hapi/boom");
var _sloSchema = require("@kbn/slo-schema");
var _slo = require("../../services/slo");
var _fetch_historical_summary = require("../../services/slo/fetch_historical_summary");
var _find_slo_definitions = require("../../services/slo/find_slo_definitions");
var _get_burn_rates = require("../../services/slo/get_burn_rates");
var _get_diagnosis = require("../../services/slo/get_diagnosis");
var _get_preview_data = require("../../services/slo/get_preview_data");
var _get_slo_instances = require("../../services/slo/get_slo_instances");
var _historical_summary_client = require("../../services/slo/historical_summary_client");
var _manage_slo = require("../../services/slo/manage_slo");
var _summary_search_client = require("../../services/slo/summary_search_client");
var _transform_generators = require("../../services/slo/transform_generators");
var _create_observability_server_route = require("../create_observability_server_route");
/*
 * Copyright Elasticsearch B.V. and/or licensed to Elasticsearch B.V. under one
 * or more contributor license agreements. Licensed under the Elastic License
 * 2.0; you may not use this file except in compliance with the Elastic License
 * 2.0.
 */

const transformGenerators = {
  'sli.apm.transactionDuration': new _transform_generators.ApmTransactionDurationTransformGenerator(),
  'sli.apm.transactionErrorRate': new _transform_generators.ApmTransactionErrorRateTransformGenerator(),
  'sli.kql.custom': new _transform_generators.KQLCustomTransformGenerator(),
  'sli.metric.custom': new _transform_generators.MetricCustomTransformGenerator(),
  'sli.histogram.custom': new _transform_generators.HistogramTransformGenerator()
};
const assertPlatinumLicense = async context => {
  const licensing = await context.licensing;
  const hasCorrectLicense = licensing.license.hasAtLeast('platinum');
  if (!hasCorrectLicense) {
    throw (0, _boom.forbidden)('Platinum license or higher is needed to make use of this feature.');
  }
};
const createSLORoute = (0, _create_observability_server_route.createObservabilityServerRoute)({
  endpoint: 'POST /api/observability/slos 2023-10-31',
  options: {
    tags: ['access:slo_write']
  },
  params: _sloSchema.createSLOParamsSchema,
  handler: async ({
    context,
    params,
    logger
  }) => {
    await assertPlatinumLicense(context);
    const esClient = (await context.core).elasticsearch.client.asCurrentUser;
    const soClient = (await context.core).savedObjects.client;
    const repository = new _slo.KibanaSavedObjectsSLORepository(soClient);
    const transformManager = new _slo.DefaultTransformManager(transformGenerators, esClient, logger);
    const createSLO = new _slo.CreateSLO(esClient, repository, transformManager);
    const response = await createSLO.execute(params.body);
    return response;
  }
});
const updateSLORoute = (0, _create_observability_server_route.createObservabilityServerRoute)({
  endpoint: 'PUT /api/observability/slos/{id} 2023-10-31',
  options: {
    tags: ['access:slo_write']
  },
  params: _sloSchema.updateSLOParamsSchema,
  handler: async ({
    context,
    params,
    logger
  }) => {
    await assertPlatinumLicense(context);
    const esClient = (await context.core).elasticsearch.client.asCurrentUser;
    const soClient = (await context.core).savedObjects.client;
    const repository = new _slo.KibanaSavedObjectsSLORepository(soClient);
    const transformManager = new _slo.DefaultTransformManager(transformGenerators, esClient, logger);
    const updateSLO = new _slo.UpdateSLO(repository, transformManager, esClient);
    const response = await updateSLO.execute(params.path.id, params.body);
    return response;
  }
});
const deleteSLORoute = (0, _create_observability_server_route.createObservabilityServerRoute)({
  endpoint: 'DELETE /api/observability/slos/{id} 2023-10-31',
  options: {
    tags: ['access:slo_write']
  },
  params: _sloSchema.deleteSLOParamsSchema,
  handler: async ({
    request,
    context,
    params,
    logger,
    dependencies: {
      getRulesClientWithRequest
    }
  }) => {
    await assertPlatinumLicense(context);
    const esClient = (await context.core).elasticsearch.client.asCurrentUser;
    const soClient = (await context.core).savedObjects.client;
    const rulesClient = getRulesClientWithRequest(request);
    const repository = new _slo.KibanaSavedObjectsSLORepository(soClient);
    const transformManager = new _slo.DefaultTransformManager(transformGenerators, esClient, logger);
    const deleteSLO = new _slo.DeleteSLO(repository, transformManager, esClient, rulesClient);
    await deleteSLO.execute(params.path.id);
  }
});
const getSLORoute = (0, _create_observability_server_route.createObservabilityServerRoute)({
  endpoint: 'GET /api/observability/slos/{id} 2023-10-31',
  options: {
    tags: ['access:slo_read']
  },
  params: _sloSchema.getSLOParamsSchema,
  handler: async ({
    context,
    params
  }) => {
    await assertPlatinumLicense(context);
    const soClient = (await context.core).savedObjects.client;
    const esClient = (await context.core).elasticsearch.client.asCurrentUser;
    const repository = new _slo.KibanaSavedObjectsSLORepository(soClient);
    const summaryClient = new _slo.DefaultSummaryClient(esClient);
    const getSLO = new _slo.GetSLO(repository, summaryClient);
    const response = await getSLO.execute(params.path.id, params.query);
    return response;
  }
});
const enableSLORoute = (0, _create_observability_server_route.createObservabilityServerRoute)({
  endpoint: 'POST /api/observability/slos/{id}/enable 2023-10-31',
  options: {
    tags: ['access:slo_write']
  },
  params: _sloSchema.manageSLOParamsSchema,
  handler: async ({
    context,
    params,
    logger
  }) => {
    await assertPlatinumLicense(context);
    const soClient = (await context.core).savedObjects.client;
    const esClient = (await context.core).elasticsearch.client.asCurrentUser;
    const repository = new _slo.KibanaSavedObjectsSLORepository(soClient);
    const transformManager = new _slo.DefaultTransformManager(transformGenerators, esClient, logger);
    const manageSLO = new _manage_slo.ManageSLO(repository, transformManager);
    const response = await manageSLO.enable(params.path.id);
    return response;
  }
});
const disableSLORoute = (0, _create_observability_server_route.createObservabilityServerRoute)({
  endpoint: 'POST /api/observability/slos/{id}/disable 2023-10-31',
  options: {
    tags: ['access:slo_write']
  },
  params: _sloSchema.manageSLOParamsSchema,
  handler: async ({
    context,
    params,
    logger
  }) => {
    await assertPlatinumLicense(context);
    const soClient = (await context.core).savedObjects.client;
    const esClient = (await context.core).elasticsearch.client.asCurrentUser;
    const repository = new _slo.KibanaSavedObjectsSLORepository(soClient);
    const transformManager = new _slo.DefaultTransformManager(transformGenerators, esClient, logger);
    const manageSLO = new _manage_slo.ManageSLO(repository, transformManager);
    const response = await manageSLO.disable(params.path.id);
    return response;
  }
});
const findSLORoute = (0, _create_observability_server_route.createObservabilityServerRoute)({
  endpoint: 'GET /api/observability/slos 2023-10-31',
  options: {
    tags: ['access:slo_read']
  },
  params: _sloSchema.findSLOParamsSchema,
  handler: async ({
    context,
    params,
    logger
  }) => {
    var _params$query;
    await assertPlatinumLicense(context);
    const soClient = (await context.core).savedObjects.client;
    const esClient = (await context.core).elasticsearch.client.asCurrentUser;
    const repository = new _slo.KibanaSavedObjectsSLORepository(soClient);
    const summarySearchClient = new _summary_search_client.DefaultSummarySearchClient(esClient, logger);
    const findSLO = new _slo.FindSLO(repository, summarySearchClient);
    const response = await findSLO.execute((_params$query = params === null || params === void 0 ? void 0 : params.query) !== null && _params$query !== void 0 ? _params$query : {});
    return response;
  }
});
const findSloDefinitionsRoute = (0, _create_observability_server_route.createObservabilityServerRoute)({
  endpoint: 'GET /internal/observability/slos/_definitions',
  options: {
    tags: ['access:slo_read']
  },
  params: _sloSchema.findSloDefinitionsParamsSchema,
  handler: async ({
    context,
    params
  }) => {
    await assertPlatinumLicense(context);
    const soClient = (await context.core).savedObjects.client;
    const repository = new _slo.KibanaSavedObjectsSLORepository(soClient);
    const findSloDefinitions = new _find_slo_definitions.FindSLODefinitions(repository);
    const response = await findSloDefinitions.execute(params.query.search);
    return response;
  }
});
const fetchHistoricalSummary = (0, _create_observability_server_route.createObservabilityServerRoute)({
  endpoint: 'POST /internal/observability/slos/_historical_summary',
  options: {
    tags: ['access:slo_read']
  },
  params: _sloSchema.fetchHistoricalSummaryParamsSchema,
  handler: async ({
    context,
    params
  }) => {
    await assertPlatinumLicense(context);
    const soClient = (await context.core).savedObjects.client;
    const esClient = (await context.core).elasticsearch.client.asCurrentUser;
    const repository = new _slo.KibanaSavedObjectsSLORepository(soClient);
    const historicalSummaryClient = new _historical_summary_client.DefaultHistoricalSummaryClient(esClient);
    const fetchSummaryData = new _fetch_historical_summary.FetchHistoricalSummary(repository, historicalSummaryClient);
    const response = await fetchSummaryData.execute(params.body);
    return response;
  }
});
const getSLOInstancesRoute = (0, _create_observability_server_route.createObservabilityServerRoute)({
  endpoint: 'GET /internal/observability/slos/{id}/_instances',
  options: {
    tags: ['access:slo_read']
  },
  params: _sloSchema.getSLOInstancesParamsSchema,
  handler: async ({
    context,
    params
  }) => {
    await assertPlatinumLicense(context);
    const soClient = (await context.core).savedObjects.client;
    const esClient = (await context.core).elasticsearch.client.asCurrentUser;
    const repository = new _slo.KibanaSavedObjectsSLORepository(soClient);
    const getSLOInstances = new _get_slo_instances.GetSLOInstances(repository, esClient);
    const response = await getSLOInstances.execute(params.path.id);
    return response;
  }
});
const getDiagnosisRoute = (0, _create_observability_server_route.createObservabilityServerRoute)({
  endpoint: 'GET /internal/observability/slos/_diagnosis',
  options: {
    tags: []
  },
  params: undefined,
  handler: async ({
    context
  }) => {
    const esClient = (await context.core).elasticsearch.client.asCurrentUser;
    const licensing = await context.licensing;
    try {
      const response = await (0, _get_diagnosis.getGlobalDiagnosis)(esClient, licensing);
      return response;
    } catch (error) {
      if (error instanceof _elasticsearch.errors.ResponseError && error.statusCode === 403) {
        throw (0, _boom.forbidden)('Insufficient Elasticsearch cluster permissions to access feature.');
      }
      throw (0, _boom.failedDependency)(error);
    }
  }
});
const getSloBurnRates = (0, _create_observability_server_route.createObservabilityServerRoute)({
  endpoint: 'POST /internal/observability/slos/{id}/_burn_rates',
  options: {
    tags: ['access:slo_read']
  },
  params: _sloSchema.getSLOBurnRatesParamsSchema,
  handler: async ({
    context,
    params
  }) => {
    await assertPlatinumLicense(context);
    const esClient = (await context.core).elasticsearch.client.asCurrentUser;
    const soClient = (await context.core).savedObjects.client;
    const burnRates = await (0, _get_burn_rates.getBurnRates)(params.path.id, params.body.instanceId, params.body.windows, {
      soClient,
      esClient
    });
    return {
      burnRates
    };
  }
});
const getPreviewData = (0, _create_observability_server_route.createObservabilityServerRoute)({
  endpoint: 'POST /internal/observability/slos/_preview',
  options: {
    tags: ['access:slo_read']
  },
  params: _sloSchema.getPreviewDataParamsSchema,
  handler: async ({
    context,
    params
  }) => {
    await assertPlatinumLicense(context);
    const esClient = (await context.core).elasticsearch.client.asCurrentUser;
    const service = new _get_preview_data.GetPreviewData(esClient);
    return await service.execute(params.body);
  }
});
const sloRouteRepository = {
  ...createSLORoute,
  ...deleteSLORoute,
  ...disableSLORoute,
  ...enableSLORoute,
  ...fetchHistoricalSummary,
  ...findSloDefinitionsRoute,
  ...findSLORoute,
  ...getSLORoute,
  ...updateSLORoute,
  ...getDiagnosisRoute,
  ...getSloBurnRates,
  ...getPreviewData,
  ...getSLOInstancesRoute
};
exports.sloRouteRepository = sloRouteRepository;