AISln/Platform/AI.Platform.Page/Pages/Media/Media.razor.cs

using AI.Platform.Core;
using AI.Platform.Core.Entity.Media;
using AI.Platform.Core.Entity.Site;
using AI.Platform.Page.Pages.Media.Model;
using AI.Platform.Page.Pages.Site.Model;
using AntDesign;
using AntDesign.TableModels;
using Dm.util;
using Microsoft.AspNetCore.Components;
using Microsoft.AspNetCore.Components.Forms;
using Microsoft.JSInterop;
using SqlSugar;
using System.Data.Common;
using System.Text.Json;
using System.Threading.Tasks;

namespace AI.Platform.Page.Pages.Media;

public partial class Media
{
    /// <summary>
    /// 
    /// </summary>
    [Inject] NavigationManager NavigationManager { get; set; }
    /// <summary>
    /// 数据库仓储
    /// </summary>
    [Inject] SqlSugarRepository<MediaEntity> _Repository { get; set; }

    [Inject] SqlSugarRepository<SiteEntity> _SiteRepository { get; set; }
    /// <summary>
    /// 
    /// </summary>
    [Inject] IJSRuntime IJSRuntime { get; set; }
    /// <summary>
    ///
    /// </summary>
    private ITable _Table;
    /// <summary>
    ///
    /// </summary>
    private IEnumerable<SystemMenu> _SelectedRows = [];
    /// <summary>
    /// 广告列表信息
    /// </summary>
    private List<MediaInfoModel> _DataSource;
    /// <summary>
    ///
    /// </summary>
    private int Pi = 1;
    /// <summary>
    ///
    /// </summary>
    private int Ps = 20;

    /// <summary>
    /// 总条数
    /// </summary>
    private int Total = 0;
    /// <summary>
    /// 加载
    /// </summary>
    private bool Loading = false;

    /// <summary>
    /// 查询过滤条件
    /// </summary>
    private FilterData filterData { set; get; } = new();

    /// <summary>
    /// 编辑弹窗
    /// </summary>
    private UpdateMediaDialog updateMediaDialog { set; get; } = new();

    /// <summary>
    /// 标识弹窗是否显示
    /// </summary>
    private bool isOpen { set; get; } = false;

    private MediaDialogModel model = new MediaDialogModel();

    // <summary>
    /// 站点
    /// </summary>
    private List<SiteInfo> Sites;

    /// <summary>
    /// 打开编辑弹窗
    /// </summary>
    /// <param name="type">类型：1：新增；2：编辑；3：删除</param>
    /// <param name="media">广告信息</param>
    /// <returns></returns>
    private async Task ShowDialog(int type, MediaInfoModel? media)
    {
        model = new MediaDialogModel();
        model.Type = type;
        model.siteInfos = Sites;
        var siteinfo = Sites.Find(it => it.Id == Global.CurrentUser.SiteId);
        if (type ==1 && siteinfo != null)
        {
            model.GroupID = siteinfo.ParentId;
            model.BusinessUnitID = siteinfo.Id;
        }

        if (type == 2 || type == 3)
        {
            model.Id = media?.Id;
            model.GroupID = media?.GroupID ?? -1;
            model.BusinessUnitID = media?.BusinessUnitID ?? -1;
            model.FileName = media?.FileName ?? "";
            model.GuidFileName = media?.GuidFileName ?? "";
            model.FileExtension = media?.FileExtension ?? "";
            model.SavePath = media?.SavePath ?? "";
            model.MediaUploader = media?.MediaUploader ?? "";
            model.StartTime = media?.StartTime;
            model.EndTime = media?.EndTime;
            model.EffecitiveTime = media?.EffecitiveTime;
            model.FailureTime = media?.FailureTime;
            model.MediaState = media?.MediaState ?? 0;
            model.MachineStateList = JsonSerializer.Deserialize<List<string>>(media?.MachineStateList ?? "[]");
            model.Remark = media?.Remark ?? "";
        }

        isOpen = true;
    }
    
    /// <summary>
    /// 编辑弹窗信息回调
    /// </summary>
    /// <param name="model"></param>
    private async Task OnDialogCallback(MediaDialogModel model)
    {
        Console.WriteLine(model);
        switch (model.Type)
        {
            case 1:
                await _Repository.InsertAsync(model.ToCompany());
                break;
            case 2:
                MediaEntity mediaEntity = model.ToCompany();
                await _Repository.Context.Updateable(mediaEntity).
                    UpdateColumns(it => new { it.GroupId,it.BusinessUnitId,  it.MediaState,it.MachineState, it.StartTime, it.EndTime ,it.EffectiveTime,it.FailureTime,it.Remark })
                    .ExecuteCommandAsync();
                break;
            case 3:
                await _Repository.DeleteByIdAsync(model.Id);
                if(model.SavePath.IsNotNullOrEmpty())
                {
                    File.Delete(model.SavePath);
                }
                break;
        }
        await Query();
    }

    /// <summary>
    /// 编辑弹窗是否显示回调
    /// </summary>
    /// <param name="isOpen"></param>
    private void OnDialogVisibleCallback(bool isOpen)
    {
        this.isOpen = isOpen;
    }

    private async Task searchSitesAsync()
    {
        if (Global.CurrentUser.Account == "admin")
        {
            Sites = await _SiteRepository.AsQueryable()
                .Select<SiteInfo>()
                .ToListAsync();
        }
        else
        {
            Sites = await _SiteRepository.AsQueryable()
                .Where(it => it.Id == Global.CurrentUser.SiteId || it.ParentId == Global.CurrentUser.SiteId)
                .Select<SiteInfo>()
                .ToListAsync();
        }
    }

    /// <summary>
    /// 表格查询
    /// </summary>
    /// <param name="query"></param>
    /// <returns></returns>
    private async Task OnChange(QueryModel<MediaInfoModel> query)
        => await Query();

    /// <summary>
    /// 查
    /// </summary>
    /// <returns></returns>
    private async Task Query()
    {
        Loading = true;

        var query =  _Repository.AsQueryable()
            .LeftJoin<SiteEntity>((media,site) => media.BusinessUnitId == site.Id)
            .WhereIF(filterData.searchFileName != null, media => media.FileName.Contains(filterData.searchFileName))
            .WhereIF(filterData.searchMediaUploader != null, media => media.Uploader.Contains(filterData.searchMediaUploader))
            .WhereIF(filterData.searchMediaState != null && filterData.searchMediaState != -1, media => media.MediaState == filterData.searchMediaState)
            .WhereIF(filterData.searchStartTime != null && filterData.searchEndTime != null, media => media.StartTime >= filterData.searchStartTime && media.EndTime <= filterData.searchEndTime)
            .WhereIF(filterData.searchEffecitiveTime != null && filterData.searchFailureTime != null, media => media.EffectiveTime >= filterData.searchEffecitiveTime && media.FailureTime <= filterData.searchFailureTime)
            .WhereIF(filterData.searchStartEditTime != null && filterData.searchEndEditTime != null, media => media.EditTime >= filterData.searchStartEditTime && media.EditTime <= filterData.searchEndEditTime);

        if (filterData.searchMachineStateList.IsNotNullOrEmpty())
        {
            Expressionable<MediaEntity> expressionable = Expressionable.Create<MediaEntity>();
            foreach (var state in filterData.searchMachineStateList)
            {
                var jsonQuoted = $"\"{state}\"";
                expressionable.Or(m => m.MachineState.Contains(jsonQuoted));
            }
            query = query.Where(expressionable.ToExpression());
        }

        Total = await query.CountAsync();
        _DataSource = await query
            .Select((media, site) => new MediaInfoModel()
            {
                Id = media.Id,
                GroupID = media.GroupId,
                BusinessUnitID = media.BusinessUnitId,
                SavePath = media.LocalPath,
                FileName = media.FileName,
                GuidFileName = media.GuidFileName,
                FileExtension = media.FileExtension,
                MediaUploader = media.Uploader,
                MachineStateList = media.MachineState,
                MediaState = media.MediaState,
                SiteName = site.Name,
                StartTime = media.StartTime,
                EndTime = media.EndTime,
                EffecitiveTime = media.EffectiveTime,
                FailureTime = media.FailureTime,
                EditTime = media.EditTime,
                Remark = media.Remark,
            })
            .OrderByDescending(media => media.EditTime)
            .Skip((filterData.currentPage - 1) * filterData.pageSize)
            .Take(filterData.pageSize)
            .ToListAsync();

        Loading = false;
    }

    Func<PaginationTotalContext, string> showTotal = ctx => $"总数 {ctx.Total} ";

    private async Task OnPageChange(PaginationEventArgs args)
    {
        filterData.pageSize = args.PageSize;
        filterData.currentPage = args.Page;
        await Query();
    }

    /// <summary>
    /// 清空查询条件
    /// </summary>
    private void HandleReset()
    {
        filterData = new();
    }

    /// <summary>
    /// 单选选择器选择事件
    /// </summary>
    /// <param name="value">选择的值</param>
    private void OnSelectItemChange(string value)
    {
        Console.WriteLine(value);
        int state = -1;
        int.TryParse(value, out state);
        filterData.searchMediaState = state;
    }

    /// <summary>
    /// 多选选择器选择事件
    /// </summary>
    /// <param name="values">选择的值</param>
    private void OnSelectItemsChange(IEnumerable<string> values)
    {
        Console.WriteLine(values);
        filterData.searchMachineStateList = values.ToList();
    }

    /// <summary>
    /// 日期选择器选择回调
    /// </summary>
    /// <param name="value">选择的日期</param>
    /// <param name="type">1：有效时间段；2：更新时间；3：播放时段</param>
    private void onDateChage(DateRangeChangedEventArgs<DateTime?[]> value,int type)
    {
        switch (type)
        {
            case 1:
                filterData.searchEffecitiveTime = value.Dates[0];
                filterData.searchFailureTime = value.Dates[1];
                break;
            case 2:
                filterData.searchStartEditTime = value.Dates[0];
                filterData.searchEndEditTime = value.Dates[1];
                break;
            case 3:
                DateTime? startTime = value.Dates[0];
                DateTime? endTime = value.Dates[1];
                filterData.searchStartTime = startTime?.Hour;
                filterData.searchEndTime = endTime?.Hour;
                break;
        }
        
    }

    protected override async void OnInitialized()
    {

    }

    protected override async Task OnAfterRenderAsync(bool firstRender)
    {
        if (firstRender)
        {
            await NavigationManager.RedirectLogin(IJSRuntime);
            await Query();
            await searchSitesAsync();
        }
    }

    private async Task OnChange(QueryModel<SystemMenu> query)
        => await Query();


    /// <summary>
    /// 查找条件
    /// </summary>
    public class FilterData
    {
        /// <summary>
        /// 页码
        /// </summary>
        public int currentPage { set; get; } = 1;

        /// <summary>
        /// 页数
        /// </summary>
        public int pageSize { set; get; } = 10;

        /// <summary>
        /// 要查找的文件名
        /// </summary>
        public string? searchFileName { set; get; }

        /// <summary>
        /// 要查找文件开始播放时间
        /// </summary>
        public int? searchStartTime { set; get; }

        /// <summary>
        /// 要查找文件结束播放时间
        /// </summary>
        public int? searchEndTime { set; get; }

        /// <summary>
        /// 要查找文件生效时间
        /// </summary>
        public DateTime? searchEffecitiveTime { set; get; }

        /// <summary>
        /// 要查找文件失效时间
        /// </summary>
        public DateTime? searchFailureTime { set; get; }

        /// <summary>
        /// 要查找文件油机状态
        /// </summary>
        public List<string>? searchMachineStateList { set; get; }

        /// <summary>
        /// 要查找文件广告状态 0:禁用；1：可用
        /// </summary>
        public int? searchMediaState { set; get; }

        /// <summary>
        /// 要查找文件上传人
        /// </summary>
        public string? searchMediaUploader { set; get; }

        /// <summary>
        /// 根据文件修改时间范围查找（开始时间）
        /// </summary>
        public DateTime? searchStartEditTime { set; get; }

        /// <summary>
        /// 根据文件修改时间范围查找（结束时间）
        /// </summary>
        public DateTime? searchEndEditTime { set; get; }

    }
}