EquipmentPropController.cs 5.53 KB
using HHECS.DAQShared.Models;
using HHECS.DAQWebClient.Dtos;
using HHECS.DAQWebClient.Models;
using HHECS.DAQWebClient.ViewModel;
using LinqKit;
using Microsoft.AspNetCore.Authorization;
using Microsoft.AspNetCore.Mvc;
using System.Linq.Expressions;

namespace HHECS.DAQWebClient.Controllers
{
    [Authorize]
    public class EquipmentPropController : Controller
    {
        private readonly IFreeSql _freeSql;
        private readonly ILogger<EquipmentPropController> _logger;

        public EquipmentPropController(IFreeSql freeSql, ILogger<EquipmentPropController> logger)
        {
            _freeSql = freeSql;
            _logger = logger;
        }

        public IActionResult Index(int id)
        {
            return View(new EquipmentPropQueryModel
            {
                EquipmentId = id
            });
        }

        [HttpGet]
        public async Task<IActionResult> Load(EquipmentPropQueryModel model, int page, int limit)
        {
            try
            {
                var query = _freeSql.Queryable<EquipmentProp>().Where(GetFilter(model));
                var result = await query.Skip((page - 1) * limit).Take(limit).ToListAsync();
                var total = await query.CountAsync();
                return Ok(new ResultDto<List<EquipmentProp>>
                {
                    Code = 0,
                    Count = total,
                    Data = result
                });
            }
            catch (Exception ex)
            {
                return Ok(new ResultDto<List<EquipmentProp>>
                {
                    Code = 500,
                    Msg = ex.Message
                });
            }
        }

        private static Expression<Func<EquipmentProp, bool>> GetFilter(EquipmentPropQueryModel model)
        {
            var filter = PredicateBuilder.New<EquipmentProp>(x => x.EquipmentId == model.EquipmentId);
            if (!string.IsNullOrWhiteSpace(model.Code))
            {
                filter = filter.And(x => x.Code.Contains(model.Code));
            }
            if (!string.IsNullOrWhiteSpace(model.Name))
            {
                filter = filter.And(x => x.Name.Contains(model.Name));
            }
            if (model.PropType != null)
            {
                filter = filter.And(x => x.PropType == model.PropType);
            }
            return filter;
        }

        [HttpPost]
        [Authorize(Roles = $"{nameof(RoleType.Admin)}")]
        public async Task<IActionResult> Add(EquipmentProp model)
        {
            try
            {
                model.CreatedBy = HttpContext.User.Identity?.Name ?? string.Empty;
                model.Created = DateTime.Now;
                await _freeSql.Insert<EquipmentProp>(model).ExecuteAffrowsAsync();
                var msg = "新增成功";
                _logger.LogInformation(msg);
                return Ok(new ResultDto
                {
                    Code = 0,
                    Msg = msg
                });
            }
            catch (Exception ex)
            {
                var msg = $"新增失败:{ex.Message}";
                _logger.LogError(msg);
                return Ok(new ResultDto
                {
                    Code = 500,
                    Msg = msg
                });
            }
        }

        [HttpPost]
        [Authorize(Roles = $"{nameof(RoleType.Admin)}")]
        public async Task<IActionResult> Update(EquipmentProp model)
        {
            try
            {
                var user = HttpContext.User.Identity?.Name ?? string.Empty;
                await _freeSql.Update<EquipmentProp>(model.Id).Set(x => new EquipmentProp
                {
                    Code = model.Code,
                    Name = model.Name,
                    PropType = model.PropType,
                    DataType = model.DataType,
                    Address = model.Address,
                    MonitorCompareValue = model.MonitorCompareValue,
                    MonitorFailure = model.MonitorFailure,
                    MonitorNormal = model.MonitorNormal,
                    Remark = model.Remark,
                    UpdatedBy = user,
                    Updated = DateTime.Now
                }).ExecuteAffrowsAsync();

                var msg = $"更新成功";
                _logger.LogInformation(msg);
                return Ok(new ResultDto
                {
                    Code = 0,
                    Msg = msg
                });
            }
            catch (Exception ex)
            {
                var msg = $"更新失败:{ex.Message}";
                _logger.LogError(msg);
                return Ok(new ResultDto
                {
                    Code = 500,
                    Msg = msg
                });
            }
        }

        [HttpPost]
        [Authorize(Roles = $"{nameof(RoleType.Admin)}")]
        public async Task<IActionResult> Delete(int[] ids)
        {
            try
            {
                await _freeSql.Delete<EquipmentProp>().Where(x => ids.Contains(x.Id)).ExecuteAffrowsAsync();
                var msg = "删除成功";
                _logger.LogInformation(msg);
                return Ok(new ResultDto
                {
                    Code = 0,
                    Msg = msg
                });
            }
            catch (Exception ex)
            {
                var msg = $"删除失败:{ex.Message}";
                _logger.LogError(msg);
                return Ok(new ResultDto
                {
                    Code = 500,
                    Msg = msg
                });
            }
        }
    }
}