Tiobon.Web.Core/Tiobon.Core.Services/Ghre/Ghre_CourseWareServices.cs

using System.Data;
using System.IO.Compression;
using Microsoft.AspNetCore.Hosting;
using Newtonsoft.Json;
using Newtonsoft.Json.Linq;
using SqlSugar;
using Tiobon.Core.Common;
using Tiobon.Core.Common.Caches;
using Tiobon.Core.IRepository.Base;
using Tiobon.Core.IServices;
using Tiobon.Core.Model;
using Tiobon.Core.Model.Models;
using Tiobon.Core.Services.BASE;

namespace Tiobon.Core.Services;

/// <summary>
/// 课件 (服务)
/// </summary>
public class Ghre_CourseWareServices : BaseServices<Ghre_CourseWare, Ghre_CourseWareDto, InsertGhre_CourseWareInput, EditGhre_CourseWareInput>, IGhre_CourseWareServices
{
    private readonly IBaseRepository<Ghre_CourseWare> _dal;
    private IGhre_CourseServices _ghre_CourseServices;
    private readonly IWebHostEnvironment _hostingEnvironment;
    private IGhre_CourseWareAttachmentServices _ghre_CourseWareAttachmentServices;

    public Ghre_CourseWareServices(ICaching caching,
        IGhre_CourseServices ghre_CourseServices,
        IWebHostEnvironment hostingEnvironment,
        IGhre_CourseWareAttachmentServices ghre_CourseWareAttachmentServices,
        IBaseRepository<Ghre_CourseWare> dal)
    {
        this._dal = dal;
        base.BaseDal = dal;
        base._caching = caching;
        _ghre_CourseServices = ghre_CourseServices;
        _ghre_CourseWareAttachmentServices = ghre_CourseWareAttachmentServices;
        _hostingEnvironment = hostingEnvironment;
    }

    public override async Task<long> Add(InsertGhre_CourseWareInput entity)
    {
        if (entity.CourseIds2.Any())
        {
            entity.CourseIds = JsonConvert.SerializeObject(entity.CourseIds2);
            var courses = await _ghre_CourseServices.Query(x => entity.CourseIds2.Contains(x.Id));
            entity.CourseNames = string.Join(",", courses.Select(x => x.CourseName));
        }
        var result = await base.Add(entity);
        entity.Attachments.ForEach(x => x.CourseWareId = result);
        await _ghre_CourseWareAttachmentServices.Add(entity.Attachments);
        return result;
    }

    public override async Task<bool> Update(long Id, EditGhre_CourseWareInput editModel)
    {
        if (editModel.CourseIds2.Any())
        {
            editModel.CourseIds = JsonConvert.SerializeObject(editModel.CourseIds2);
            var courses = await _ghre_CourseServices.Query(x => editModel.CourseIds2.Contains(x.Id));
            editModel.CourseNames = string.Join(",", courses.Select(x => x.CourseName));
        }

        await _ghre_CourseWareAttachmentServices.Delete(x => x.CourseWareId == Id);
        editModel.Attachments.ForEach(x => x.CourseWareId = Id);
        await _ghre_CourseWareAttachmentServices.Add(editModel.Attachments);

        return await base.Update(Id, editModel);
    }

    public override async Task<ServiceFormResult<Ghre_CourseWareDto>> QueryForm(QueryForm body)
    {
        var result = await base.QueryForm(body);
        string courseIds = result.result.DT_TableDataT1[0].CourseIds;
        if (!string.IsNullOrWhiteSpace(courseIds))
        {
            result.result.DT_TableDataT1[0].CourseIds2 = JsonConvert.DeserializeObject<List<long>>(courseIds);
            if (result.result.DT_TableDataT1[0].CourseIds2.Any())
            {

            }
        }

        else result.result.DT_TableDataT1[0].CourseIds2 = new List<long>();

        result.result.DT_TableDataT1[0].Attachments = await _ghre_CourseWareAttachmentServices.Query(x => x.CourseWareId == body.id);

        if (body.doType == "Copy")
        {
            result.result.DT_TableDataT1[0].CourseWareNo = null;
            result.result.DT_TableDataT1[0].CourseWareName = null;
        }
        return result;

    }

    public override async Task<ServicePageResult<Ghre_CourseWareDto>> QueryFilterPage(QueryBody filter)
    {
        bool? IsAllowDownload = null;
        if (filter.jsonParam != null)
            foreach (JProperty jProperty in filter.jsonParam.Properties())
            {
                var name = jProperty.Name;
                var value = jProperty.Value.ToString();
                if (name != "IsAllowDownload")
                    continue;
                if (!string.IsNullOrWhiteSpace(value))
                {
                    var jsonParam = JsonConvert.DeserializeObject<JsonParam>(value);

                    switch (name)
                    {
                        case "IsAllowDownload":
                            IsAllowDownload = Convert.ToBoolean(jsonParam.columnValue);
                            break;
                        default:
                            break;
                    }
                }
            }
        string condition = string.Empty;
        if (IsAllowDownload != null)
        {
            string sql = @$"SELECT DISTINCT B.Id
                                FROM Ghre_CourseWareAttachment A
                                     JOIN Ghre_CourseWare B ON A.CourseWareId = B.Id AND B.IsEnable = 1
                                WHERE A.IsEnable = 1 AND A.IsAllowDownload = '{IsAllowDownload}'";
            var entitys = await Db.Ado.SqlQueryAsync<long>(sql);
            if (entitys.Any())
                condition = "Id IN (" + string.Join(",", entitys.Select(x => x)) + ")";
        }
        var result = await base.QueryFilterPage(filter, condition);
        var data = result.result.DT_TableDataT1;
        var attachmentIds = data.Select(x => x.Id).ToList();
        var attachments = await _ghre_CourseWareAttachmentServices.Query(x => x.CourseWareId != null && attachmentIds.Contains(x.CourseWareId.Value));
        data.ForEach(async x =>
        {
            if (!string.IsNullOrWhiteSpace(x.CourseIds))
                x.CourseIds2 = JsonConvert.DeserializeObject<List<long>>(x.CourseIds);

            x.StudyDuration = $"{x.Hours}小时{x.Minutes}分钟";
            x.SourceLabel = await GetParaLabel("CourseWareSource", x.Source);
            x.Attachments = attachments.Where(a => a.CourseWareId == x.Id).ToList();
        });
        result.result.DT_TableDataT1 = data;
        return result;

    }


    public async Task<ServiceResult<string>> DownZip(long id)
    {
        var result = await base.QueryById(id);
        if (result is null)
            return ServiceResult<string>.OprateFailed("无效的课件ID！");
        var attachments = await _ghre_CourseWareAttachmentServices.Query(x => x.CourseWareId == id);
        var webRootPath = _hostingEnvironment.WebRootPath;
        var outPath = $"/files/upload/{result.CourseWareName}_{DateTime.Now.ToString("yyyyMMddHHmmss")}.zip";
        var files = attachments.Select(x => $"{webRootPath}{"\\" + x.RelativePath}").ToArray();
        if (files.Length > 0)
        {
            if (files.Length > 1)
                CreateZip($"{webRootPath}{outPath}", files);
            else
                outPath = attachments[0].RelativePath;
            return ServiceResult<string>.OprateSuccess(null, outPath);
        }
        else
            return ServiceResult<string>.OprateFailed("该课件无附件！");

    }

    public static void CreateZip(string zipPath, string[] filesToZip)
    {
        if (File.Exists(zipPath))
        {
            throw new IOException("File already exists.");
        }

        using (FileStream zipFile = new FileStream(zipPath, FileMode.Create))
        {
            using (ZipArchive zipArchive = new ZipArchive(zipFile, ZipArchiveMode.Create))
            {
                foreach (string file in filesToZip)
                {
                    if (File.Exists(file))
                    {
                        ZipArchiveEntry entry = zipArchive.CreateEntryFromFile(file, Path.GetFileName(file));
                    }
                }
            }
        }
    }
}