QYZH.InteractiveMagazine/QYZH.InteractiveMagazine.Service/JournalPageService.cs

using Microsoft.Extensions.Configuration;
using Newtonsoft.Json;
using QYZH.InteractiveMagazine.Common.Extensions;
using QYZH.InteractiveMagazine.Infrastructure.OSS;
using QYZH.InteractiveMagazine.Infrastructure.RabbitMQ;
using QYZH.InteractiveMagazine.IService;
using QYZH.InteractiveMagazine.Models.Common;
using QYZH.InteractiveMagazine.Models.Dto.Journal;
using QYZH.InteractiveMagazine.Models.Entity;
using QYZH.InteractiveMagazine.Models.Enum;
using QYZH.InteractiveMagazine.Repository;
using System.Diagnostics;
using Yitter.IdGenerator;

namespace QYZH.InteractiveMagazine.Service;

public class JournalPageService(BaseRepository<Journal> JournalRepository,
                            OssService ossService,
                            IHttpClientFactory httpClientFactory,
                            IConfiguration configuration,
                            IRabbitMQService rabbitMqService,
                            BaseRepository<JournalPageTask> JournalPageTaskRepository,
                            BaseRepository<JournalPageTaskAnswer> JournalPageTaskAnswerRepository) : BaseRepository<JournalPage>, IJournalPageService
{

    public async Task<long> InsertAsync(JournalAddV2Input input)
    {

        var Journal = await JournalRepository.Queryable().Where(w => w.Id == input.JournalId).FirstAsync();
        BusinessException.ThrowIf(Journal.IsNull(), "未找到书本");

        BusinessException.ThrowIf(Journal?.Status == (int)JournalStatusEnum.Archive, "书籍已归档不能修改");

        var pages = new List<JournalPage>();
        //var dotMatrixpages = new List<DotMatrixPage>();

        //var dotMatrixpage = new DotMatrixPage()
        //{
        //    Id = YitIdHelper.NextId(),
        //    DotMatrixNoteJournalId = input.JournalId,
        //    WidthMilliMeter = Journal.Width,
        //    HightMilliMeter = Journal.Height,
        //};

        var pageTemp = new JournalPage()
        {
            JournalId = input.JournalId,
            JournalCatalogId = input.JournalCatalogId,
            //DotMatrixPageId = dotMatrixpage.Id,
            Url = input.Url,
            PageNum = input.PageNum,
        };

        //dotMatrixpages.Add(dotMatrixpage);
        pages.Add(pageTemp);

        await UseTranAsync(async () =>
        {
            //using var uow = Context.Ado.BeginTran();
            var pageData = await base.InsertRangeAsync(pages);
            BusinessException.ThrowIf(pageData.IsNull(), "创建页失败");

            //var result = await dotMatrixPageRepository.InsertRangeAsync(dotMatrixpages);
            //BusinessException.ThrowIf(result, "创建点阵页失败");
        });

        return pages.Count; // 返回主目录ID
    }

    public async Task<bool> UpdateAsync(PageLayoutInput input)
    {
        var page = await Queryable().Where(w => w.Id == input.Id).FirstAsync();
        BusinessException.ThrowIf(page == null, "不存在此页");

        var Journal = await JournalRepository.GetByIdAsync(page.JournalId);
        BusinessException.ThrowIf(Journal == null, "不存在此书");

        BusinessException.ThrowIf(Journal?.Status == (int)JournalStatusEnum.Archive, "书籍已归档不能修改");
        var transResult = await UseTranAsync(async () =>
        {
            //await dotMatrixPageRepository.Updateable().SetColumns(s => s.Area == input.Layout)
            //                                            .SetColumns(s => s.AreaPoints == dotMatrixPage.Area)
            //                                            .SetColumns(s => s.WidthMilliMeter == dotMatrixPage.WidthMilliMeter)
            //                                            .SetColumns(s => s.HightMilliMeter == dotMatrixPage.HightMilliMeter)
            //                                            .SetColumns(s => s.WidthDotMatrix == dotMatrixPage.WidthDotMatrix)
            //                                            .SetColumns(s => s.HightDotMatrix == dotMatrixPage.HightDotMatrix)
            //                                           .Where(w => w.Id == page.DotMatrixPageId).ExecuteCommandAsync();

            page.Layout = input.Layout;
            base.Update(page);

            input.TasksImages?.ForEach(it =>
            {
                var key = $"journal/{Journal.Id}/{input.Id}/{it.TaskId}/qustion.{it.Url.ToExtension()}";
                ossService.CopyObject(it.Url.RemoveDomain(), key);
                JournalPageTaskRepository.Updateable().SetColumns(s => s.TaskUrl, key).Where(w => w.Id == it.TaskId).ExecuteCommand();
            });
            return true;
        });
        return transResult;
    }

    /// <summary>
    /// 修改书页的点阵码
    /// </summary>
    /// <param name="JournalId"></param>
    /// <returns></returns>
    public async Task<bool> UpdatePageNoAsync(long JournalId)
    {
        var msRes = await rabbitMqService.SendAsync(new RabbitMQSendParam { Exchange = "ex.journal", Queue = "mq.journal.dotcode.auto", RoutingKey = "rk.journal.dotcode.auto", Data = JournalId });//发生消息
        return msRes;
    }

    public async Task<JournalPageV2Output> DetailAsync(long id)
    {
        var output = await Queryable()
           //.LeftJoin<DotMatrixPage>((a, b) => a.DotMatrixPageId == b.Id)
           .Where(a => a.Id == id)
           .Select(a => new JournalPageV2Output
           {
               JournalId = a.JournalId,
               JournalCatalogId = a.JournalCatalogId,
               JournalPageId = a.Id,
               Url = a.Url,
               Layout = a.Layout,
               PageNum = a.PageNum,
           })
           .FirstAsync();

        if (output != null)
        {
            var tasks = await JournalPageTaskRepository.Queryable()
                .Where(a => a.JournalPageId == output.JournalPageId)
                .ToListAsync();

            if (tasks.Count > 0)
            {
                var taskIds = tasks.Select(t => t.Id).ToList();
                var allAnswers = await JournalPageTaskAnswerRepository.Queryable()
                    .Where(a => taskIds.Contains(a.JournalPageTaskId))
                    .ToListAsync();

                output.Tasks = tasks.Select(t => new JournalPageTaskV2Output
                {
                    Id = t.Id,
                    GroupId = t.GroupId,
                    No = t.No,
                    Type = t.Type,
                    Answers = allAnswers
                        .Where(a => a.JournalPageTaskId == t.Id)
                        .Select(a => new JournalTaskAnswerOutput
                        {
                            Id = a.Id,
                            Answer = a.Answer,
                            AnswerUrl = a.AnswerUrL
                        }).ToList()
                }).ToList();
            }
        }
        //if (output?.Areas != null)
        //    output.Areas = await _JournalPageOtherRepository.Queryable().Where(w => w.JournalPageId == output.JournalPageId).Select<JournalPageOtherOutput>().ToListAsync();

        return output;
    }

    public async Task<bool> DeleteAsync(long id)
    {
        return await Deleteable().Where(d => d.Id == id).ExecuteCommandAsync() > 0;
    }
    //public async Task<List<JournalPageNoArticleOutput>> PageNoArticleAsync(long JournalId)
    //{
    //    return await Queryable().Where(d => d.JournalId == JournalId)
    //        .Where(w => w.JournalArticleId == null)
    //        .ToListAsync(x => new JournalPageNoArticleOutput()
    //        {
    //            Id = x.Id,
    //            PageUrl = x.Url,
    //            PageNum = x.PageNum
    //        });
    //}

    private int MillimeterToDotMatrixUnit(float millimeterValue)
    {
        return (int)(millimeterValue * 8 / 0.3);
    }
}

public class JournalDotPage_Task
{
    public int X { get; set; }
    public int Y { get; set; }
    public int W { get; set; }
    public int H { get; set; }
}

public class JournalDotPage_Answer
{
    public int X { get; set; }
    public int Y { get; set; }
    public int W { get; set; }
    public int H { get; set; }
}

public class JournalDotPage_Area
{
    public JournalDotPage_Task Task { get; set; }

    public List<JournalDotPage_Answer> AnswerList { get; set; }

    public long TaskId { get; set; }

}