regulatory_net/Admin.Bodk.Device/Services/DeviceService.cs

using System.ComponentModel;
using Admin.Bodk.Device.Entities.equipment;
using Admin.Bodk.Device.Entities.TaskChain;
using Admin.NET.Core;
using Furion.DatabaseAccessor;
using Furion.DependencyInjection;
using Furion.DynamicApiController;
using Furion.FriendlyException;
using Mapster;
using Microsoft.AspNetCore.Authentication.JwtBearer;
using Microsoft.AspNetCore.Authorization;
using Microsoft.AspNetCore.Mvc;
using NewLife.Caching;
using SqlSugar;

namespace Admin.Bodk.Device.Services;

/// <summary>
/// 设备管理服务
/// </summary>
[ApiDescriptionSettings(Order = 2)]
public class DeviceService : IDynamicApiController, ITransient
{
    private readonly SqlSugarRepository<Entities.Device.Device> _repository;

    private readonly SqlSugarRepository<TaskChain> _taskChainRepository;

    private readonly ICache _cache;

    public DeviceService(SqlSugarRepository<Entities.Device.Device> repository,
        SqlSugarRepository<TaskChain> taskChainRepository,
        ICache cache)
    {
        _repository = repository;
        _taskChainRepository = taskChainRepository;
        _cache = cache;
    }

    /// <summary>
    /// 获取设备列表
    /// </summary>
    /// <param name="input"></param>
    /// <returns></returns>
    [DisplayName("获取设备列表")]
    
    [Authorize(AuthenticationSchemes = JwtBearerDefaults.AuthenticationScheme + "," + SignatureAuthenticationDefaults.AuthenticationScheme)]
    public async Task<SqlSugarPagedList<EquipmentDto>> PostList(DeviceInpt input)
    {
        return await _repository.AsQueryable()
            // .LeftJoin<TaskChain.TaskChain>((u, a) => u.Id == a.EquipmentId)
            .WhereIF(!string.IsNullOrWhiteSpace(input.Name),
                m => m.Name != null && m.Name.Contains(input.Name))
            .WhereIF(!string.IsNullOrWhiteSpace(input.Type), m => m.Type == input.Type)
            .Select<EquipmentDto>((u) => new EquipmentDto()
            {
                Id = u.Id,
                Name = u.Name,
                Type = u.Type,
                BaseName = u.BaseName,
                PicUrl = u.PicUrl,
                Address = u.Address,
                Remark = u.Remark,
                Code = u.Code,
                Ip = u.Ip,
                Status = u.Status,
                CreateTime = u.CreateTime,
            })
            .Mapper(d =>
            {
                var cache = _cache.Get<dynamic>($"bodk:device:{d.Code}:summary");
                if (cache is not null)
                {
                    d.Temperature = cache?.TankTopTemperature;
                    d.LiquidNitrogenHeight = cache?.LiquidHeight;
                    d.Humidity = cache?.CavityHumidity;
                }
                else
                {
                    d.Temperature = -192.5f;
                    d.LiquidNitrogenHeight = 182;
                    d.Humidity = 0.5f;
                }
            })
            .ToPagedListAsync(input.Page, input.PageSize);
    }

    /// <summary>
    /// 增加设备
    /// </summary>
    /// <param name="input"></param>
    /// <returns></returns>
    [UnitOfWork]
    [ApiDescriptionSettings(Name = "Add"), HttpPost]
    [DisplayName("增加设备")]
    public async Task<long> AddEquipment(EquipmentDto input)
    {
        if (input is null) throw Oops.Oh("参数不能为空");
        var equipment = input.Adapt<Entities.Device.Device>();
        // if( a is double b)
        // {
        //     Console.WriteLine(b);
        // }
        var newEquipment = await _repository.AsInsertable(equipment).ExecuteReturnEntityAsync();
        // if (input?.TaskChainList is { Count: > 0 })
        // {
        //     foreach (var taskChain in input.TaskChainList)
        //     {
        //         taskChain.EquipmentId = newEquipment.Id;
        //         await _taskChainRepository.AsInsertable(taskChain).ExecuteReturnEntityAsync();
        //     }
        // }
        input.Id = newEquipment.Id;
        return newEquipment.Id;
    }

    /// <summary>
    /// 更新设备
    /// </summary>
    /// <param name="input"></param>
    /// <returns></returns>
    [UnitOfWork]
    [ApiDescriptionSettings(Name = "Update"), HttpPost]
    [DisplayName("更新设备")]
    public async Task Update(EquipmentDto input)
    {
        _taskChainRepository.AsDeleteable().Where(tc => tc.EquipmentId == input.Id).ExecuteCommand();
        // if (input?.TaskChainList is { Count: > 0 })
        // {
        //     foreach (var taskChain in input.TaskChainList)
        //     {
        //         taskChain.EquipmentId = input.Id;
        //         await _taskChainRepository.AsInsertable(taskChain).ExecuteReturnEntityAsync();
        //     }
        // }
        await _repository.AsUpdateable(input.Adapt<Entities.Device.Device>())
            .UpdateColumns(m => new { m.Type, m.Name, m.Remark, m.Code })
            .ExecuteCommandAsync();
    }

    /// <summary>
    /// 删除设备
    /// </summary>
    /// <param name="input"></param>
    /// <returns></returns>
    [UnitOfWork]
    [ApiDescriptionSettings(Name = "Delete"), HttpPost]
    [DisplayName("删除设备")]
    public async Task Delete(DeleteEquipmentInput input)
    {
        var user = await _repository.GetFirstAsync(u => u.Id == input.Id) ?? throw Oops.Oh("设备不存在");

        await _repository.DeleteAsync(user);
    }
}