qlhb/Ropin.Inspection.Api/TdevDevStoreController.cs

using Microsoft.AspNetCore.Authorization;
using Microsoft.AspNetCore.Mvc;
using Microsoft.Extensions.Logging;
using Newtonsoft.Json;
using Ropin.Inspection.Api.Common;
using Ropin.Inspection.Api.Controllers;
using Ropin.Inspection.Model;
using Ropin.Inspection.Service;
using System;
using System.Collections.Generic;
using System.Linq;
using System.Threading.Tasks;
using Ropin.Core.Extensions.Redis;
using Ropin.Core.Common;
using Ropin.Inspection.Service.DEV.Interface;
using Ropin.Inspection.Model.ViewModel.DEV;
using Newtonsoft.Json.Linq;
using Ropin.Inspection.Model.SearchModel.DEV;
using System.Text.RegularExpressions;
using Ropin.Inspection.Common.Helper;
using Microsoft.Extensions.FileSystemGlobbing.Internal;
using K4os.Compression.LZ4.Internal;
using Ropin.Inspection.Common;

namespace Ropin.Inspection.Api
{

    public class TdevDevStoreController : BaseController
    {
        public ILogger<TdevDevStoreController> _logger { get; }
        private readonly ITdevDevStoreService _TdevDevStoreService;
        private readonly IPushMsgService _pushMsgService;
        private readonly IRedisBasketRepository _redisBasketRepository;
        private readonly ITdevDevOpeAccountService _tdevDevOpeAccountService;
        private readonly IDevDevOpeAccountConfigService _devDevOpeAccountConfigService;
        private readonly IRedisBasketRepository _redisService;
        /// <summary>
        /// 构造函数
        /// </summary>
        /// <param name="TdevDevStoreService"></param>
        /// <param name="logger"></param>
        public TdevDevStoreController(ITdevDevStoreService TdevDevStoreService, ITdevDevOpeAccountService tdevDevOpeAccountService,IRedisBasketRepository redisBasketRepository, IPushMsgService pushMsgService, ILogger<TdevDevStoreController> logger, IDevDevOpeAccountConfigService devDevOpeAccountConfigService, IRedisBasketRepository redisService)
        {
            _TdevDevStoreService = TdevDevStoreService;
            _logger = logger;
            _pushMsgService = pushMsgService;
            _redisBasketRepository = redisBasketRepository;
            _tdevDevOpeAccountService = tdevDevOpeAccountService;
            _devDevOpeAccountConfigService = devDevOpeAccountConfigService;
            _redisService = redisService;
        }
        /// <summary>
        /// 通过id获取业主设备信息
        /// </summary>
        /// <param name="id"></param>
        /// <returns></returns>
        [HttpGet("GetDevStoreAsync/{id}")]
        [AllowAnonymous]
        public async Task<ApiResult> GetDevStoreAsync(string id)
        {
            if (string.IsNullOrEmpty(id))
            {
                return new ApiResult(ReturnCode.GeneralError);
            }
            try
            {
                var content = await _TdevDevStoreService.GetConditionAsync(new TdevDevStoreSearchModel { C_ID = id, type= "details" });
                var dev = content.FirstOrDefault();
                
                var user = await _TdevDevStoreService.GetUserByDevStoreIdAndRoleNameAsync(id,"设备管理员");
                if(dev != null)
                dev.DevManager = user?.C_Name;
                return new ApiResult<TdevDevStoreViewModel>(dev);
            }
            catch (Exception ex)
            {
                return new ApiResult(ReturnCode.GeneralError, ex.Message);
            }
        }
        /// <summary>
        /// 通过id获取业主设备二维码地址信息
        /// </summary>
        /// <param name="id"></param>
        /// <returns></returns>
        [HttpGet("GetDevStoreQRCodeAsync/{id}")]
        public async Task<ApiResult> GetDevStoreQRCodeAsync(string id)
        {
            if (string.IsNullOrEmpty(id))
            {
                return new ApiResult(ReturnCode.GeneralError);
            }
            try
            {
                var content = await _TdevDevStoreService.GetDevStoreQRCodeAsync(id);
                return new ApiResult<string>(content);
            }
            catch (Exception ex)
            {
                return new ApiResult(ReturnCode.GeneralError, ex.Message);
            }
        }

        /// <summary>
        /// 获取所有业主设备
        /// </summary>
        /// <returns></returns>
        [HttpGet("GetDevStoresAsync")]
        public async Task<ApiResult> GetDevStoresAsync()
        {
            try
            {
                var contentList = await _TdevDevStoreService.GetAllAsync();
                return new ApiResult<IEnumerable<TdevDevStoreViewModel>>(contentList);
            }
            catch (Exception ex)
            {
                return new ApiResult(ReturnCode.GeneralError, ex.Message);
            }
        }

        /// <summary>
        /// 通过业主设备名称条件查询
        /// </summary>
        /// <param name="searchModel"></param>
        /// <returns></returns>
        [HttpPost("GetDevStoresByAsync")]
        public async Task<ApiResult> GetDevStoresByAsync(TdevDevStoreSearchModel searchModel)
        {
            if (searchModel == null)
            {
                return new ApiResult(ReturnCode.ArgsError);
            }
            //searchModel.IsPagination = false;
            try
            {
                var contentList = await _TdevDevStoreService.GetConditionAsync(searchModel);

                PagesModel<TdevDevStoreViewModel> pages = new PagesModel<TdevDevStoreViewModel>(searchModel.IsPagination ? contentList.Skip((searchModel.PageIndex - 1) * searchModel.PageSize).Take(searchModel.PageSize) : contentList, searchModel);

                return new ApiResult<PagesModel<TdevDevStoreViewModel>>(pages);
            }
            catch (Exception ex)
            {
                return new ApiResult(ReturnCode.GeneralError, ex.Message);
            }
        }

        /// <summary>
        /// 通过业主设备名称条件查询（数据包时间）
        /// </summary>
        /// <param name="searchModel"></param>
        /// <returns></returns>
        [HttpPost("GetDevStoresByAsync1")]
        public async Task<ApiResult> GetDevStoresByAsync1(TdevDevStoreSearchModel searchModel)
        {
            if (searchModel == null)
            {
                return new ApiResult(ReturnCode.ArgsError);
            }
            //searchModel.IsPagination = false;
            try
            {
                var contentList = await _TdevDevStoreService.GetConditionAsync(searchModel);
                foreach (var item in contentList)
                {
                    if (item!=null)
                    {
                        var content = await _redisBasketRepository.GetValue(RedisKey.Fanyibox_DevStore_ + item.C_ID);
                        if (content!=null)
                        {
                            try
                            {
                                JObject jsonObj = JObject.Parse(content);
                                if (jsonObj != null&& jsonObj["package"].Any())
                                {
                                    JObject address = (JObject)jsonObj["package"];
                                    item.packageTime = address["time"].ToString();
                                }
                            }
                            catch
                            {

                            }
                        }
                    }
                }
                PagesModel<TdevDevStoreViewModel> pages = new PagesModel<TdevDevStoreViewModel>(searchModel.IsPagination ? contentList.Skip((searchModel.PageIndex - 1) * searchModel.PageSize).Take(searchModel.PageSize) : contentList, searchModel);

                return new ApiResult<PagesModel<TdevDevStoreViewModel>>(pages);
            }
            catch (Exception ex)
            {
                return new ApiResult(ReturnCode.GeneralError, ex.Message);
            }
        }
        
        /// <summary>
        /// 业主设备状态统计
        /// </summary>
        /// <param name="searchModel"></param>
        /// <returns></returns>
        [HttpPost("GetDevStoreStatusCount")]
        public async Task<ApiResult> GetDevStoreStatusCount(TdevDevStoreSearchModel searchModel)
        {
            if (searchModel == null)
            {
                return new ApiResult(ReturnCode.ArgsError);
            }
            try
            {
                var contentList = await _TdevDevStoreService.GetDevStoreStatusCount(searchModel);
                PagesModel<DevStoreStatusGroup> pages = new PagesModel<DevStoreStatusGroup>(searchModel.IsPagination ? contentList.Skip((searchModel.PageIndex - 1) * searchModel.PageSize).Take(searchModel.PageSize) : contentList, searchModel);
                return new ApiResult<PagesModel<DevStoreStatusGroup>>(pages);
            }
            catch (Exception ex)
            {
                return new ApiResult(ReturnCode.GeneralError, ex.Message);
            }
        }
        /// <summary>
        /// 创建业主设备
        /// </summary>
        /// <param name="content"></param>
        /// <returns></returns>
        [HttpPost("CreateDevStoreAsync")]
        public async Task<ApiResult> CreateDevStoreAsync(TdevDevStoreViewModel content)
        {
            if (content == null)
            {
                return new ApiResult(ReturnCode.ArgsError);
            }
            try
            {
                await _TdevDevStoreService.CreateOneAsync(content);
                await _redisService.Set(RedisEnum.TdevDevStoreUpdateRedisKey, "1", TimeSpan.FromDays(7));
            }
            catch (Exception ex)
            {
                return new ApiResult(ReturnCode.GeneralError, ex.Message);
            }
            return new ApiResult(ReturnCode.Success);
        }

        /// <summary>
        /// 删除业主设备
        /// </summary>
        /// <param name="id"></param>
        /// <returns></returns>
        [HttpDelete("DeleteDevStoreAsync/{id}")]
        public async Task<ApiResult> DeleteDevStoreAsync(string id)
        {
            if (string.IsNullOrEmpty(id))
            {
                return new ApiResult(ReturnCode.GeneralError);
            }
            try
            {
                await _TdevDevStoreService.DeleteAsync(id);
                await _redisService.Set(RedisEnum.TdevDevStoreUpdateRedisKey, "1", TimeSpan.FromDays(7));
            }
            catch (Exception ex)
            {
                return new ApiResult(ReturnCode.GeneralError, ex.Message);
            }
            return new ApiResult(ReturnCode.Success);
        }
        /// <summary>
        /// 更新业主设备
        /// </summary>
        /// <param name="id"></param>
        /// <param name="updateModel"></param>
        /// <returns></returns>
        [HttpPut("UpdateDevStoreAsync/{id}")]
        [AllowAnonymous]
        public async Task<ApiResult> UpdateDevStoreAsync(string id, TdevDevStoreUpdateModel updateModel)
        {
            if (string.IsNullOrEmpty(id))
            {
                return new ApiResult(ReturnCode.GeneralError);
            }
            try
            {
                await _TdevDevStoreService.UpdateAsync(id, updateModel);
                await _redisService.Set(RedisEnum.TdevDevStoreUpdateRedisKey, "1", TimeSpan.FromDays(7));
            }
            catch (Exception ex)
            {
                return new ApiResult(ReturnCode.GeneralError, ex.Message);
            }
            return new ApiResult(ReturnCode.Success);
        }

        /// <summary>
        /// 通过二维码获取点及设备信息
        /// </summary>
        /// <param name="qRCode"></param>
        /// <param name="storeCode"></param>
        /// <returns></returns>
        [HttpGet("GetDevStoreByQRCodeAsync/{qRCode}/{storeCode}")]
        [AllowAnonymous]
        public async Task<ApiResult> GetDevStoreByQRCodeAsync(string qRCode, string storeCode)
        {
            try
            {
                if (string.IsNullOrEmpty(qRCode) || string.IsNullOrEmpty(storeCode))
                {
                    return new ApiResult(ReturnCode.GeneralError);
                }
                var spot = await _TdevDevStoreService.GetDevStoreByQRCodeAsync(qRCode, storeCode);
                if (null == spot)
                {
                    return new ApiResult<TdevDevStoreDetailViewModel>(spot, ReturnCode.ResultError, "没找到此二维码对应的点，请联系管理员！");
                }
                return new ApiResult<TdevDevStoreDetailViewModel>(spot);
            }
            catch (Exception ex)
            {
                return new ApiResult(ReturnCode.GeneralError, ex.Message);
            }
        }
        /// <summary>
        /// 操作设备
        /// </summary>
        /// <param name="mode"></param>
        /// <returns></returns>
        [HttpPost("DevOperateByQRCodeAsync")]
        [AllowAnonymous]
        public async Task<ApiResult> DevOperateByQRCodeAsync(DevOperateCreateModel mode)
        {
            if (mode == null)
            {
                return new ApiResult(ReturnCode.ArgsError);
            }
            try
            {
                await _TdevDevStoreService.DevOperateByQRCodeAsync(mode);
                //await _redisBasketRepository.Set(RedisKey.Fanyibox_Ope_DevStore + mode.C_DevStoreCode, mode.C_Type, TimeSpan.FromDays(7));
                await _pushMsgService.PushAlarmMsgAsync(new TpushMsgModel
                {
                    C_DevStoreCode = mode.C_DevStoreCode,
                    C_MsgTypeCode = "MSG_TYPE_011",
                    Msg = mode.C_Remark,
                    Subject = "设备启停 " + mode.C_LogMsg,
                    DevNumber = String.Empty,
                    DevName =String.Empty,
                    GenerationType = 2,
                    msgStatus = 4,
                }, "设备启停");
                //string strContent = "";
                //await _tdevDevOpeAccountService.CreateOneAsync(new TdevDevOpeAccountViewModel{ C_DevStoreCode = mode.C_DevStoreCode,C_Content = strContent });

            }
            catch (Exception ex)
            {
                return new ApiResult(ReturnCode.GeneralError, ex.Message);
            }
            return new ApiResult(ReturnCode.Success);
        }
        /// <summary>
        /// 获取设备运行点配置
        /// </summary>
        /// <param name="id"></param>
        /// <returns></returns>
        [HttpGet("GetDevStoreRunSpotConfigAsync/{id}")]
        [AllowAnonymous]
        public async Task<ApiResult> GetDevStoreRunSpotConfigAsync(string id)
        {
            if (string.IsNullOrEmpty(id))
            {
                return new ApiResult(ReturnCode.GeneralError);
            }
            try
            {
                //TDEV_DevRunSpot
                //var content = await _TdevDevStoreService.GetConditionAsync(new TdevDevStoreSearchModel { C_ID = id });
                //TdevDevStoreRunSpotConfigViewModel mode = new TdevDevStoreRunSpotConfigViewModel();
                ////RunSpotConfig f1 = new RunSpotConfig() { Name = "排污口编号",Value = "325465465" };
                ////RunSpotConfig f2 = new RunSpotConfig() { Name = "设施名称",Value = "VOCs治理设施" };
                ////mode.RunSpotConfigList = new List<RunSpotConfig>() { f1,f2};
                //if (content.FirstOrDefault().C_RunSpotConfig == null)
                //    return new ApiResult<IEnumerable<string>>(new List<string>());
                //else
                //return new ApiResult<TdevDevStoreRunSpotConfigViewModel>(JsonConvert.DeserializeObject<TdevDevStoreRunSpotConfigViewModel>(content.FirstOrDefault().C_RunSpotConfig));
                var content = await _devDevOpeAccountConfigService.GetDevOpeAccountConfigModelAsync(id);
                if (content == null|| string.IsNullOrEmpty(content.C_Config))
                {
                    return new ApiResult<IEnumerable<string>>(new List<string>());
                }
                else
                {
                    return new ApiResult<TdevDevOpeAccountConfigViewModel>(JsonConvert.DeserializeObject<TdevDevOpeAccountConfigViewModel>(content.C_Config));
                }
            }
            catch (Exception ex)
            {
                return new ApiResult(ReturnCode.GeneralError, ex.Message);
            }
        }
        /// <summary>
        /// 更新设备运行点配置
        /// </summary>
        /// <param name="id"></param>
        /// <param name="updateModel"></param>
        /// <returns></returns>

        [HttpPut("UpdateDevStoreRunSpotConfigAsync/{id}")]
        public async Task<ApiResult> UpdateDevStoreRunSpotConfigAsync(string id, TdevDevStoreRunSpotConfigViewModel updateModel)
        {
            if (string.IsNullOrEmpty(id)|| updateModel == null || updateModel.RunSpotConfigList == null || updateModel.RunSpotConfigList.Count() == 0)
            {
                return new ApiResult(ReturnCode.ArgsError);
            }
            try
            {
                string pattern = @"[^a-zA-Z0-9\u4e00-\u9fa5]";// 定义正则表达式模式，匹配非字母、数字和汉字的字符
                foreach (var item in updateModel.RunSpotConfigList)
                {
                    if (string.IsNullOrEmpty(item.Name))
                    {
                        string LabPInYIn = ChineseAndEnglishHelper.GetLedgerConfigurationEnglishTab(item.Label);
                        int cut = updateModel.RunSpotConfigList.Where(t => t.Name == LabPInYIn).ToList().Count();
                        if (cut > 0)
                        {
                            LabPInYIn = LabPInYIn + cut;
                        }
                        item.Name = LabPInYIn;
                    }
                    else
                    {
                        string vals = Regex.Replace(item.Name, pattern, ""); // 替换匹配到的字符为空
                        item.Name = vals;
                    }
                }
                await _TdevDevStoreService.UpdateDevStoreRunSpotConfigAsync(id, updateModel);
            }
            catch (Exception ex)
            {
                return new ApiResult(ReturnCode.GeneralError, ex.Message);
            }
            return new ApiResult(ReturnCode.Success);
        }
        /// <summary>
        ///  更新设备用户配置
        /// </summary>
        /// <param name="id"></param>
        /// <param name="updateModel"></param>
        /// <returns></returns>
        [HttpPut("UpdateDevStoreUserConfigAsync/{id}")]
        [AllowAnonymous]
        public async Task<ApiResult> UpdateDevStoreUserConfigAsync(string id, TdevDevStoreUserConfigViewModel updateModel)
        {
            if (string.IsNullOrEmpty(id))
            {
                return new ApiResult(ReturnCode.GeneralError);
            }
            try
            {
                await _TdevDevStoreService.UpdateDevStoreUserConfigAsync(id, updateModel);
                await _redisService.Set(RedisEnum.TdevDevStoreUpdateRedisKey, "1", TimeSpan.FromDays(7));
            }
            catch (Exception ex)
            {
                return new ApiResult(ReturnCode.GeneralError, ex.Message);
            }
            return new ApiResult(ReturnCode.Success);
        }
        /// <summary>
        /// 获取设备用户配置
        /// </summary>
        /// <param name="id"></param>
        /// <returns></returns>
        [HttpGet("GetDevStoreUserConfigAsync/{id}")]
        [AllowAnonymous]
        public async Task<ApiResult> GetDevStoreUserConfigAsync(string id)
        {
            if (string.IsNullOrEmpty(id))
            {
                return new ApiResult(ReturnCode.GeneralError);
            }
            try
            {
                var content = await _TdevDevStoreService.GetConditionAsync(new TdevDevStoreSearchModel { C_ID = id });
                if(content.FirstOrDefault().C_UserConfig == null)
                {
                    return new ApiResult<IEnumerable<DevStoreUser>>(new List<DevStoreUser>());
                }
                else
                {
                    IEnumerable<DevStoreUser> users = JsonConvert.DeserializeObject<IEnumerable<DevStoreUser>>(content.FirstOrDefault().C_UserConfig).OrderBy(t=>t.Sort);
                    return new ApiResult<IEnumerable<DevStoreUser>>(users);
                }
            }
            catch (Exception ex)
            {
                return new ApiResult(ReturnCode.GeneralError, ex.Message);
            }
        }

        /// <summary>
        /// 拷贝业主设备信息
        /// </summary>
        /// <param name="id"></param>
        /// <returns></returns>
        [HttpPost("CopyDevStoreInfo")]
        [AllowAnonymous]
        public async Task<ApiResult> CopyDevStoreInfo(string id)
        {
            if (string.IsNullOrEmpty(id))
            {
                return new ApiResult(ReturnCode.GeneralError);
            }
            try
            {
                await _TdevDevStoreService.CopyCreateOneAsync(id);
                await _redisService.Set(RedisEnum.TdevDevStoreUpdateRedisKey, "1", TimeSpan.FromDays(7));
                return new ApiResult(ReturnCode.Success);
            }
            catch (Exception ex)
            {
                return new ApiResult(ReturnCode.GeneralError, ex.Message);
            }
        }

    }
}