DD.WellWorkover.Cloud/AsbCloudInfrastructure/Repository/FaqRepository.cs

using AsbCloudApp.Data;
using AsbCloudApp.Exceptions;
using AsbCloudApp.Repositories;
using AsbCloudApp.Requests;
using AsbCloudApp.Services;
using AsbCloudDb;
using AsbCloudDb.Model;
using Mapster;
using Microsoft.EntityFrameworkCore;
using System;
using System.Collections.Generic;
using System.Linq;
using System.Threading;
using System.Threading.Tasks;

namespace AsbCloudInfrastructure.Repository;

/// <summary>
/// сервис по работе с faq-вопросами
/// </summary>
public class FaqRepository : IFaqRepository
{
    private readonly IAsbCloudDbContext db;
    private readonly IWellService wellService;

    public FaqRepository(IAsbCloudDbContext db, IWellService wellService)
    {
        this.db = db;
        this.wellService = wellService;
    }

    public async Task<IEnumerable<FaqDto>> GetFilteredAsync(FaqRequest request, CancellationToken token)
    {
        var query = db.Faqs.AsNoTracking();

        if (request.IsFrequently)
        {
            query = query.Where(o => o.IsFrequently);
        }
        if (request.HasAnswer)
        {
            query = query.Where(o => !string.IsNullOrEmpty(o.Answer));
        }
        if (!request.IncludeDeleted)
        {
            query = query.Where(o => o.State != Faq.StateDeleted);
        }

        var entities = query
            .OrderByDescending(e => e.DateCreatedQuestion)
            .Select(o => new FaqDto()
            {
                Id = o.Id,
                Question = o.Question,
                Answer = o.Answer,
                CounterQuestion = o.CounterQuestion,
                IsFrequently = o.IsFrequently,
                State = o.State,
                DateCreatedQuestion = o.DateCreatedQuestion,
                IdAuthorQuestion = o.IdAuthorQuestion,
                AurhorQuestionName = o.AuthorQuestion.MakeDisplayName(),
                AurhorAnswerName = (o.AuthorAnswer != null) 
                    ? o.AuthorAnswer.MakeDisplayName() 
                    : string.Empty,
            });


        var result = await entities.AsNoTracking()
            .ToArrayAsync(token)
            .ConfigureAwait(false);

        return result;

    }

    public async Task<int> InsertAsync(FaqDto faqDto, CancellationToken token)
    {
        var entity = faqDto.Adapt<Faq>();
        entity.DateCreatedQuestion = entity.DateLastEditedQuestion = DateTimeOffset.UtcNow;
        entity.CounterQuestion = 1;
        entity.State = Faq.StateOpened;
        if (!string.IsNullOrEmpty(entity.Answer))
            entity.IdAuthorAnswer = entity.IdAuthorQuestion;


        db.Faqs.Add(entity);

        await db.SaveChangesAsync(token).ConfigureAwait(false);
        return entity.Id;
    }

    public async Task<int> MergeAsync(int sourceId1, int sourceId2, bool mergeQuestions, CancellationToken token)
    {
        var sourceFaqs = db.Faqs.Where(e => e.Id == sourceId1 || e.Id == sourceId2).ToArray();
        if (sourceFaqs.Count() < 2)
            throw new ArgumentInvalidException(nameof(sourceFaqs), "Questions with target ids don't exist");

        var newFaq = new Faq()
        {
            CounterQuestion = sourceFaqs.Sum(e => e.CounterQuestion),
            State = 0,
            IsFrequently = sourceFaqs.Any(e => e.IsFrequently),
            IdAuthorQuestion = sourceFaqs.Last().IdAuthorQuestion,
            DateCreatedQuestion = DateTimeOffset.UtcNow,
            DateLastEditedQuestion = DateTimeOffset.UtcNow,
            Answer = mergeQuestions == true
                ? string.Join(Environment.NewLine, sourceFaqs.Select(e => e.Answer))
                : sourceFaqs.Last().Answer,
            Question = mergeQuestions == true
                ? string.Join(Environment.NewLine, sourceFaqs.Select(e => e.Question))
                : sourceFaqs.Last().Question,
        };

        db.Faqs.Add(newFaq);
        await db.SaveChangesAsync(token).ConfigureAwait(false);

        if (newFaq.Id == 0)
            throw new ArgumentInvalidException(nameof(sourceId1), "Error creating new question");

        foreach (var sourceFaq in sourceFaqs)
        {
            sourceFaq.IdReplacementQuestion = newFaq.Id;
            sourceFaq.State = Faq.StateDeleted;
        }
        await db.SaveChangesAsync(token).ConfigureAwait(false);

        return newFaq.Id;
    }

    public async Task<int> UpdateAsync(FaqDto dto, CancellationToken token)
    {
        var entity = dto.Adapt<Faq>();
        entity.DateLastEditedQuestion = DateTimeOffset.UtcNow;
        db.Faqs.Update(entity);
        return await db.SaveChangesAsync(token)
            .ConfigureAwait(false);
    }

    public async Task<int> MarkAsDeletedAsync(int id, CancellationToken token)
    {
        var entity = db.Faqs.FirstOrDefault(e => e.Id == id)
            ?? throw new ArgumentInvalidException(nameof(id), "Question doesn't exist");

        entity.State = Faq.StateDeleted;
        entity.DateLastEditedQuestion = DateTimeOffset.UtcNow;

        return await db.SaveChangesAsync(token)
            .ConfigureAwait(false);
    }

    public async Task<int> DeleteAsync(int id, CancellationToken token)
    {
        var faq = db.Faqs.FirstOrDefault(f => f.Id == id)
            ?? throw new ArgumentInvalidException(nameof(id), "Question doesn't exist");

        db.Faqs.Remove(faq);
        return await db.SaveChangesAsync(token);
    }
}