erp-platform/api/modules/Erp.SqlQueryManager/Erp.SqlQueryManager.Application/SqlQueryAppService.cs

using System;
using System.Linq;
using System.Threading.Tasks;
using Erp.SqlQueryManager.Application.Contracts;
using Erp.SqlQueryManager.Domain.Entities;
using Erp.SqlQueryManager.Domain.Services;
using Microsoft.AspNetCore.Mvc;
using Volo.Abp.Application.Dtos;
using Volo.Abp.Application.Services;
using Volo.Abp.Domain.Repositories;

namespace Erp.SqlQueryManager.Application;

public class SqlQueryAppService : CrudAppService<
    SqlQuery,
    SqlQueryDto,
    Guid,
    PagedAndSortedResultRequestDto,
    CreateSqlQueryDto,
    UpdateSqlQueryDto>, ISqlQueryAppService
{
    private readonly ISqlExecutorService _sqlExecutorService;

    public SqlQueryAppService(
        IRepository<SqlQuery, Guid> repository,
        ISqlExecutorService sqlExecutorService) : base(repository)
    {
        _sqlExecutorService = sqlExecutorService;
    }

    public override async Task<SqlQueryDto> CreateAsync(CreateSqlQueryDto input)
    {
        var entity = new SqlQuery(
            GuidGenerator.Create(),
            input.Code,
            input.Name,
            input.QueryText,
            input.DataSourceCode,
            CurrentTenant.Id)
        {
            Description = input.Description,
            Category = input.Category,
            Tags = input.Tags,
            IsModifyingData = input.IsModifyingData,
            Parameters = input.Parameters
        };

        await Repository.InsertAsync(entity);
        return ObjectMapper.Map<SqlQuery, SqlQueryDto>(entity);
    }

    public override async Task<SqlQueryDto> UpdateAsync(Guid id, UpdateSqlQueryDto input)
    {
        var entity = await Repository.GetAsync(id);

        entity.Name = input.Name;
        entity.Description = input.Description;
        entity.UpdateQueryText(input.QueryText);
        entity.DataSourceCode = input.DataSourceCode;
        entity.Category = input.Category;
        entity.Tags = input.Tags;
        entity.IsModifyingData = input.IsModifyingData;
        entity.Parameters = input.Parameters;

        await Repository.UpdateAsync(entity);
        return ObjectMapper.Map<SqlQuery, SqlQueryDto>(entity);
    }

    public async Task<SqlQueryExecutionResultDto> ExecuteQueryAsync(ExecuteSqlQueryDto input)
    {
        var result = input.QueryText.TrimStart().StartsWith("SELECT", StringComparison.OrdinalIgnoreCase)
            ? await _sqlExecutorService.ExecuteQueryAsync(input.QueryText, input.DataSourceCode, input.Parameters)
            : await _sqlExecutorService.ExecuteNonQueryAsync(input.QueryText, input.DataSourceCode, input.Parameters);

        return MapExecutionResult(result);
    }

    public async Task<SqlQueryExecutionResultDto> ExecuteSavedQueryAsync(Guid id)
    {
        var query = await Repository.GetAsync(id);

        var result = query.IsModifyingData
            ? await _sqlExecutorService.ExecuteNonQueryAsync(query.QueryText, query.DataSourceCode)
            : await _sqlExecutorService.ExecuteQueryAsync(query.QueryText, query.DataSourceCode);

        // Update execution statistics
        query.MarkAsExecuted();
        await Repository.UpdateAsync(query);

        return MapExecutionResult(result);
    }

    public async Task<(bool IsValid, string ErrorMessage)> ValidateQueryAsync(string sql)
    {
        return await _sqlExecutorService.ValidateSqlAsync(sql);
    }

    public async Task ActivateAsync(Guid id)
    {
        var entity = await Repository.GetAsync(id);
        entity.Activate();
        await Repository.UpdateAsync(entity);
    }

    public async Task ArchiveAsync(Guid id)
    {
        var entity = await Repository.GetAsync(id);
        entity.Archive();
        await Repository.UpdateAsync(entity);
    }

    private SqlQueryExecutionResultDto MapExecutionResult(SqlExecutionResult result)
    {
        return new SqlQueryExecutionResultDto
        {
            Success = result.Success,
            Message = result.Message,
            Data = result.Data,
            RowsAffected = result.RowsAffected,
            ExecutionTimeMs = result.ExecutionTimeMs,
            Metadata = result.Metadata
        };
    }
}