iot/projects/Platform/Api/NodeController.cs

using Infrastructure.Application.Services.Settings;
using Infrastructure.Data;
using Infrastructure.Extensions;
using IoT.Shared.Application.Domain.Entities;
using IoT.Shared.Application.Models;
using Microsoft.AspNetCore.Mvc;
using Microsoft.AspNetCore.SignalR;
using Microsoft.EntityFrameworkCore;
using Microsoft.Extensions.Logging;
using Platform.Services;
using System;
using System.ComponentModel.DataAnnotations;
using System.Linq;
using System.Threading;

namespace Platform.Apis.Controllers
{
    [ApiVersion("1.0")]
    [Route("api/v{version:apiVersion}/[controller]/[action]")]
    [ApiController]
    public class NodeController : ControllerBase
    {
        private readonly ILogger<NodeController> _logger;
        private readonly ISettingService _settingService;
        //private readonly IRepository<IoTGatewayCategoryIoTGateway> _nodeCategoryNodeRepo;
        private readonly IRepository<IoTGateway> _nodeRepo;
        private readonly IRepository<IoTDevice> _deviceRepo;
        private readonly IRepository<Organ> _organRepo;
        private readonly IHubContext<IoTCenterHub> _hub;

        public NodeController(
            ILogger<NodeController> logger,
            ISettingService settingService,
            //IRepository<IoTGatewayCategoryIoTGateway> nodeCategoryNodeRepo,
            IRepository<IoTGateway> nodeRepo,
            IRepository<IoTDevice> deviceRepo,
            IRepository<Organ> organRepo,
            IHubContext<IoTCenterHub> hub)
        {
            this._logger = logger;
            this._settingService = settingService;
            //this._nodeCategoryNodeRepo = nodeCategoryNodeRepo;
            this._nodeRepo = nodeRepo;
            this._deviceRepo = deviceRepo;
            this._organRepo = organRepo;
            this._hub = hub;
        }

        [HttpPost]
        public ActionResult GetNodes(string organNumber)
        {
            var gateways = this._organRepo.ReadOnlyTable().Where(o => o.Number == organNumber)
                .SelectMany(o => o.Buildings)
                .SelectMany(o => o.BuildingIoTGateways)
                .Select(o => o.Building)
                .SelectMany(o => o.BuildingIoTGateways)
                .Select(o => o.IoTGateway)
                .ToList();
            try
            {
                var model = this._nodeRepo.ReadOnlyTable()
                    //.WhereIf(!string.IsNullOrWhiteSpace(organNumber), o => o.BuildingIoTGateways.Any(on => on.Building.Organ.Number == organNumber))
                    .Where(o => !o.Hidden)
                    .OrderBy(o => o.Name)
                    .ToList()
                    .Select(o => new
                    {
                        o.Id,
                        o.Name,
                        o.Number,
                        o.IsOnline,
                        o.Image,
                        o.DisplayOrder,
                        Count = _deviceRepo.ReadOnlyTable().Count(d => d.NodeId == o.Id),
                        //Category = _nodeCategoryNodeRepo.ReadOnlyTable().Include(ncn => ncn.Category).FirstOrDefault(ncn => ncn.NodeId == o.Id)?.Category
                    });
                return Ok(model);
            }
            catch (Exception ex)
            {
                ex.PrintStack();
                return Problem(ex.Message);
            }
        }

        [HttpPost]
        public ActionResult GetNode([Required(ErrorMessage = nameof(RequiredAttribute))] string number)
        {
            try
            {
                var model = this._nodeRepo.ReadOnlyTable()
                    //.Include(o => o.Scenes)
                    .Include(o => o.Devices).ThenInclude(o => o.Product)
                    .Include(o => o.Devices).ThenInclude(o => o.Data)
                    .Where(o => o.Number == number)
                    .FirstOrDefault();
                //model.Scenes = model.Scenes.Where(o => !o.Hidden).OrderBy(o => o.DisplayOrder).ToList();
                return Ok(model);
            }
            catch (Exception ex)
            {
                ex.PrintStack();
                return Problem(ex.Message);
            }
        }

        [HttpPost]
        public ActionResult PowerOn([FromBody][Required(ErrorMessage = nameof(RequiredAttribute))] string number)
        {
            return this.Power(number, "On");
        }

        [HttpPost]
        public ActionResult PowerOff([FromBody][Required(ErrorMessage = nameof(RequiredAttribute))] string number)
        {
            return this.Power(number, "Off");
        }

        [HttpPost]
        public ActionResult Upload([FromBody][Required(ErrorMessage = nameof(RequiredAttribute))] string number)
        {
            this._hub.ServerToClient(Methods.UploadNode, "", number);
            return Ok();
        }

        [HttpPost]
        public IActionResult Stop([FromBody][Required(ErrorMessage = nameof(RequiredAttribute))] string number)
        {
            this._hub.ServerToClient(Methods.StopNode, "", number);
            return Ok();
        }

        [HttpPost]
        private ActionResult Power(string number, string command)
        {
            var devices = this._deviceRepo.ReadOnlyTable()
                .Include(o => o.Node)
                .Include(o => o.Product)
                .ThenInclude(o => o.Apis)
                .Where(o => o.Node.Number == number)
                .Where(o => o.Name.Contains("开关") || o.Name.Contains("插座"))
                .ToList();
            foreach (var device in devices)
            {
                try
                {
                    var api = device.Product.Apis.FirstOrDefault(o => o.Command == command);
                    if (api != null)
                    {
                        var message = $"{api.Path}{api.Command}?number={device.Number}";
                        this._hub.ServerToClient(Methods.ExecApiRequest, message, device.Node.Number, null);
                        Delay(0);
                    }
                }
                catch (Exception ex)
                {
                    ex.PrintStack();
                }
            }

            return Ok();
        }

        private void Delay(int commandDelay)
        {
            var delay = 0;
            try
            {
                delay = Convert.ToInt32(this._settingService.GetValue("delay"));
            }
            catch (Exception ex)
            {
                this._logger.LogError(ex.ToString());
            }
            if (commandDelay > 0)
            {
                delay += commandDelay;
            }
            if (delay > 0)
            {
                Thread.Sleep(delay);
            }
        }
    }
}