ProjectController.cs 18.8 KB

Edit Raw Blame History Permalink

using HHECS.BllModel;
using HHECS.DAQServer.DataFlag;
using HHECS.DAQServer.Dto.Project;
using HHECS.DAQServer.Model.HuaHengLicence;
using HHECS.DAQShared.Models;
using HHECS.DAQShared.Models.IOTCloud;
using Microsoft.AspNetCore.Mvc;
using System.Diagnostics;
using System.Text.Json;

namespace HHECS.DAQServer.Controllers
{
    [Route("api/[controller]/[action]")]
    [ApiController]
    public class ProjectController : ControllerBase
    {
        private readonly IFreeSql<IOTCloundFlag> _iotCloundFreeSql;
        private readonly IFreeSql<HuaHengLicenceFlag> _licenceFreeSql;

        public ProjectController(IFreeSql<IOTCloundFlag> iotCloundFreeSql, IFreeSql<HuaHengLicenceFlag> licenceFreeSql)
        {
            _iotCloundFreeSql = iotCloundFreeSql;
            _licenceFreeSql = licenceFreeSql;
        }

        /// <summary>
        /// 注册项目、设备
        /// </summary>
        /// <param name="model"></param>
        /// <param name="cancellationToken"></param>
        /// <returns></returns>
        [HttpPost]
        public async Task<BllResult> RegisterEquipment(RegisterEquipmentDto model, CancellationToken cancellationToken = default)
        {
            var stopwatch = new Stopwatch();
            using var uw = _iotCloundFreeSql.CreateUnitOfWork();
            using var sysInterfaceLogRepository = _iotCloundFreeSql.GetRepository<SysInterfaceLog>();
            var sysInterfaceLog = new SysInterfaceLog
            {
                Type = "上位机SN注册项目和设备",
                System = "HHECS.DAQServer",
                Method = "POST",
                Server = $"{HttpContext.Request.Host}",
                Path = HttpContext.Request.Path,
                Request = JsonSerializer.Serialize(model),
                CreateBy = "HHECS.DAQServer",
                CreateTime = DateTime.Now,
            };
            try
            {
                using var busSnProjectInfoWmsHeadRepository = uw.GetRepository<BusSnProjectInfoWmsHead>();
                using var sysRoleProjectRelRepository = uw.GetRepository<SysRoleProjectRel>();
                using var baseProjectRepository = uw.GetRepository<BaseProject>();
                using var baseFactoryRepository = uw.GetRepository<BaseFactory>();
                using var baseEquipmentRepository = uw.GetRepository<BaseEquipment>();
                using var equipmentRepository = uw.GetRepository<Equipment>();
                using var equipmentTypeRepository = uw.GetRepository<EquipmentType>();
                using var equipmentPropRepository = uw.GetRepository<EquipmentProp>();
                using var equipmentTypePropTemplateRepository = uw.GetRepository<EquipmentTypePropTemplate>();

                var result = BllResultFactory.Success();

                var busSnProjectInfoWmsHead = await busSnProjectInfoWmsHeadRepository.Where(x => x.SN == model.SN).FirstAsync(cancellationToken);
                if (busSnProjectInfoWmsHead == null)
                {
                    //设备SN不在WMS推送的表中，需要校验SN有效性，若SN有效，则使用默认项目和仓库
                    var snInfo = await _licenceFreeSql.Queryable<SnInfo>().Where(x => x.Sn == model.SN).FirstAsync(cancellationToken);
                    if (snInfo == null)
                    {
                        result = BllResultFactory.Error($"当前设备SN“{model.SN}”无效，请联系管理员获取有效SN后再试！");
                        sysInterfaceLog.Response = JsonSerializer.Serialize(result);
                        sysInterfaceLog.TotalMilliseconds = stopwatch.ElapsedMilliseconds;
                        await sysInterfaceLogRepository.InsertAsync(sysInterfaceLog);
                        return result;
                    }

                    busSnProjectInfoWmsHead = new BusSnProjectInfoWmsHead
                    {
                        CorrelatedCode = "DefaultProject",
                        OrdeName = "默认项目",
                        CreateBy = snInfo.CreatedBy,
                        CreateTime = snInfo.Created,
                    };
                }

                if (string.IsNullOrWhiteSpace(busSnProjectInfoWmsHead.OrdeName))
                {
                    result = BllResultFactory.Error($"当前SN“{model.SN}”对应的项目编号“{busSnProjectInfoWmsHead.CorrelatedCode}”项目名称为空，请联系管理员处理！");
                    sysInterfaceLog.Response = JsonSerializer.Serialize(result);
                    sysInterfaceLog.TotalMilliseconds = stopwatch.ElapsedMilliseconds;
                    await sysInterfaceLogRepository.InsertAsync(sysInterfaceLog);
                    return result;
                }

                var equipmentType = await equipmentTypeRepository.Where(x => x.Code == model.EquipmentTypeCode).FirstAsync(cancellationToken);
                if (equipmentType == null)
                {
                    result = BllResultFactory.Error($"IOT不存在编号为“{model.EquipmentTypeCode}”的设备类型数据，请联系管理员处理！");
                    sysInterfaceLog.Response = JsonSerializer.Serialize(result);
                    sysInterfaceLog.TotalMilliseconds = stopwatch.ElapsedMilliseconds;
                    await sysInterfaceLogRepository.InsertAsync(sysInterfaceLog);
                    return result;
                }

                var baseProject = await baseProjectRepository.Where(x => x.ProjectCode == busSnProjectInfoWmsHead.CorrelatedCode).FirstAsync(cancellationToken);

                if (baseProject == null)
                {
                    //项目不存在，需要创建项目
                    baseProject = new BaseProject
                    {
                        Keys = Guid.NewGuid(),
                        ProjectCode = busSnProjectInfoWmsHead.CorrelatedCode,
                        ProjectName = busSnProjectInfoWmsHead.OrdeName,
                        ProjectManager = model.ProjectManager,
                        ProjectStartTime = busSnProjectInfoWmsHead.CreateTime,
                        CreateTime = busSnProjectInfoWmsHead.CreateTime,
                        CreateBy = busSnProjectInfoWmsHead.CreateBy,
                    };
                    await baseProjectRepository.InsertAsync(baseProject, cancellationToken);

                    var sysRoleProjectRel = new SysRoleProjectRel
                    {
                        ProjectRolesKey = Guid.Parse("9D0DABCE-A0C5-4048-8CA0-421DC3959D09"),//默认管理员角色
                        ProjectKey = baseProject.Keys,
                        CreateTime = DateTime.Now,
                        CreateBy = busSnProjectInfoWmsHead.CreateBy,
                    };
                    await sysRoleProjectRelRepository.InsertAsync(sysRoleProjectRel, cancellationToken);
                }

                var baseFactory = await baseFactoryRepository.Where(x => x.FactoryCode == $"{busSnProjectInfoWmsHead.CorrelatedCode}-01").FirstAsync(cancellationToken);
                if (baseFactory == null)
                {
                    //仓库不存在，需要创建仓库
                    baseFactory = new BaseFactory
                    {
                        Keys = Guid.NewGuid(),
                        ProjectKeys = baseProject.Keys,
                        FactoryCode = $"{busSnProjectInfoWmsHead.CorrelatedCode}-01",
                        FactoryName = $"默认仓库",
                        CreateTime = DateTime.Now,
                        CreateBy = busSnProjectInfoWmsHead.CreateBy,
                    };
                    await baseFactoryRepository.InsertAsync(baseFactory, cancellationToken);
                }

                var baseEquipment = await baseEquipmentRepository.Where(x => x.EquipmentCode == model.SN).FirstAsync(cancellationToken);
                if (baseEquipment == null)
                {
                    //设备不存在，需要创建设备
                    baseEquipment = new BaseEquipment
                    {
                        EquipmentCode = model.SN,
                        EquipmentName = model.EquipmentName,
                        ProjectKeys = baseProject.Keys,
                        DestinationArea = "1",
                        IsEnable = true,
                        FactoryCode = baseFactory.FactoryCode,
                        EquipmentTypeCode = equipmentType.Code,
                        OtherCode = model.SN,
                        StartTime = busSnProjectInfoWmsHead.CreateTime,
                        CreateTime = DateTime.Now,
                        CreateBy = busSnProjectInfoWmsHead.CreateBy,
                    };
                    await baseEquipmentRepository.InsertAsync(baseEquipment, cancellationToken);
                }

                var daqEquipment = await equipmentRepository.Where(x => x.Code == baseEquipment.OtherCode).FirstAsync(cancellationToken);
                if (daqEquipment == null)
                {
                    //设备不存在，需要创建设备
                    daqEquipment = new Equipment
                    {
                        Code = baseEquipment.OtherCode,
                        Name = baseEquipment.EquipmentName,
                        FactoryCode = baseFactory.FactoryCode,
                        ProjectCode = baseProject.ProjectCode,
                        DestinationArea = baseEquipment.DestinationArea,
                        Disable = false,
                        ConnectName = $"{baseFactory.FactoryCode}-{baseEquipment.OtherCode}",
                        EquipmentTypeId = equipmentType.Id,
                        Created = DateTime.Now,
                        CreatedBy = busSnProjectInfoWmsHead.CreateBy,
                    };
                    await equipmentRepository.InsertAsync(daqEquipment, cancellationToken);
                    daqEquipment.Id = await equipmentRepository.Where(x => x.Code == baseEquipment.OtherCode).FirstAsync(x => x.Id, cancellationToken);
                    var equipmentProps = await equipmentTypePropTemplateRepository.Where(x => x.EquipmentTypeId == equipmentType.Id).ToListAsync(x => new EquipmentProp
                    {
                        Id = 0,
                        EquipmentId = daqEquipment.Id,
                        Code = x.Code,
                        Name = x.Name,
                        Address = x.Address,
                        DataType = x.DataType,
                        PropType = x.PropType,
                        MonitorFailure = x.MonitorFailure,
                        MonitorCompareValue = x.MonitorCompareValue,
                        MonitorNormal = x.MonitorNormal,
                        Remark = x.Description,
                        Created = DateTime.Now,
                        CreatedBy = busSnProjectInfoWmsHead.CreateBy,
                    }, cancellationToken);
                    await equipmentPropRepository.InsertAsync(equipmentProps, cancellationToken);
                }
                uw.Commit();
                sysInterfaceLog.Response = JsonSerializer.Serialize(result);
                sysInterfaceLog.TotalMilliseconds = stopwatch.ElapsedMilliseconds;
                await sysInterfaceLogRepository.InsertAsync(sysInterfaceLog);
                return BllResultFactory.Success();
            }
            catch (Exception ex)
            {
                uw.Rollback();
                var result = BllResultFactory.Error(ex.Message);
                sysInterfaceLog.Response = JsonSerializer.Serialize(result);
                sysInterfaceLog.TotalMilliseconds = stopwatch.ElapsedMilliseconds;
                await sysInterfaceLogRepository.InsertAsync(sysInterfaceLog);
                return result;
            }
        }

        /// <summary>
        /// 注册客户端
        /// </summary>
        /// <param name="model"></param>
        /// <param name="cancellationToken"></param>
        /// <returns></returns>
        [HttpPost]
        public async Task<BllResult<Guid>> RegisterClient(RegisterClientDto model, CancellationToken cancellationToken = default)
        {
            try
            {
                var project = await _iotCloundFreeSql.Queryable<BaseProject>().Where(p => p.ProjectCode == model.ProjectCode).FirstAsync(cancellationToken);
                if (project == null)
                {
                    return BllResultFactory.Error<Guid>($"IOT中不存在“{model.ProjectCode}”项目编号，请检查数据后重试！");
                }

                BaseFactory factory = null;
                //仓库编号为空，默认取第一个仓库编号
                if (string.IsNullOrWhiteSpace(model.FactoryCode))
                {
                    factory = await _iotCloundFreeSql.Queryable<BaseFactory>().Where(f => f.ProjectKeys == project.Keys).FirstAsync(cancellationToken);
                    if (factory == null)
                    {
                        return BllResultFactory.Error<Guid>($"项目编号“{model.ProjectCode}”不存在仓房信息，请联系管理员处理！");
                    }
                }
                else
                {
                    factory = await _iotCloundFreeSql.Queryable<BaseFactory>().Where(f => f.ProjectKeys == project.Keys && f.FactoryCode == model.FactoryCode)
                        .FirstAsync(cancellationToken);
                    if (factory == null)
                    {
                        return BllResultFactory.Error<Guid>($"项目编号“{model.ProjectCode}”不存在仓房“{model.FactoryCode}”信息，请检查数据后重试！");
                    }
                }

                var clientId = Guid.NewGuid();
                var clientName = model.Name;
                if (string.IsNullOrWhiteSpace(model.Name))
                {
                    clientName = $"{project.ProjectName}-{model.Type}";
                }

                var clientConfig = new ClientConfig
                {
                    Id = clientId,
                    ProjectCode = project.ProjectCode,
                    FactoryCode = factory.FactoryCode,
                    Name = clientName,
                    Type = model.Type,
                    LastSeenDate = DateTime.Now,
                    Created = DateTime.Now,
                };
                await _iotCloundFreeSql.Insert(clientConfig).ExecuteAffrowsAsync(cancellationToken);
                return BllResultFactory.Success(clientId);
            }
            catch (Exception ex)
            {
                return BllResultFactory.Error<Guid>(ex.Message);
            }
        }

        /// <summary>
        /// 注册客户端
        /// </summary>
        /// <param name="model"></param>
        /// <param name="cancellationToken"></param>
        /// <returns></returns>
        [HttpPost]
        public async Task<BllResult<Guid>> RegisterClient2(RegisterClientDto2 model, CancellationToken cancellationToken = default)
        {
            try
            {
                var busSnProjectInfoWmsHead = await _iotCloundFreeSql.Queryable<BusSnProjectInfoWmsHead>().Where(x => x.SN == model.SN).FirstAsync(cancellationToken);

                var projectCode = string.Empty;
                if (busSnProjectInfoWmsHead == null)
                {
                    //设备SN不在WMS推送的表中，需要校验SN有效性，若SN有效，则使用默认项目和仓库
                    var snInfo = await _licenceFreeSql.Queryable<SnInfo>().Where(x => x.Sn == model.SN).FirstAsync(cancellationToken);
                    if (snInfo == null)
                    {
                        return BllResultFactory.Error<Guid>($"当前设备SN“{model.SN}”无效，请联系管理员获取有效SN后再试！");
                    }
                    busSnProjectInfoWmsHead = new BusSnProjectInfoWmsHead
                    {
                        CorrelatedCode = "DefaultProject",
                        OrdeName = "默认项目",
                        CreateBy = snInfo.CreatedBy,
                        CreateTime = snInfo.Created,
                    };
                }

                var project = await _iotCloundFreeSql.Queryable<BaseProject>().Where(x => x.ProjectCode == busSnProjectInfoWmsHead.CorrelatedCode).FirstAsync(cancellationToken);
                if (project == null)
                {
                    return BllResultFactory.Error<Guid>($"IOT中不存在项目编号“{busSnProjectInfoWmsHead.CorrelatedCode}”，请先注册项目数据之后再申请客户端ID");
                }

                var factory = await _iotCloundFreeSql.Queryable<BaseFactory>().Where(f => f.ProjectKeys == project.Keys).FirstAsync(cancellationToken);
                if (factory == null)
                {
                    return BllResultFactory.Error<Guid>($"项目编号“{project.ProjectCode}”不存在仓房信息，请联系管理员处理！");
                }

                var clientId = Guid.NewGuid();
                var clientConfig = new ClientConfig
                {
                    Id = clientId,
                    ProjectCode = project.ProjectCode,
                    FactoryCode = factory.FactoryCode,
                    Name = model.Name,
                    Type = model.Type,
                    LastSeenDate = DateTime.Now,
                    Created = DateTime.Now,
                };
                await _iotCloundFreeSql.Insert(clientConfig).ExecuteAffrowsAsync(cancellationToken);
                return BllResultFactory.Success(clientId);
            }
            catch (Exception ex)
            {
                return BllResultFactory.Error<Guid>(ex.Message);
            }
        }

        /// <summary>
        /// SN是否绑定项目
        /// </summary>
        /// <param name="sn">设备SN</param>
        /// <returns></returns>
        [HttpPost]
        public async Task<BllResult<bool>> SNBindingProjectVerification(string sn)
        {
            try
            {
                var snVerification = await _licenceFreeSql.Queryable<SnInfo>().Where(x => x.Sn == sn).AnyAsync();
                if (!snVerification)
                {
                    return BllResultFactory.Error<bool>($"当前SN“{sn}”无效，请联系管理员获取有效SN后再试！");
                }
                var baseEquipment = await _iotCloundFreeSql.Queryable<BaseEquipment>().Where(x => x.EquipmentCode == sn).FirstAsync();
                if (baseEquipment == null)
                {
                    return BllResultFactory.Error<bool>($"当前SN“{sn}”未绑定项目");
                }
                var project = await _iotCloundFreeSql.Queryable<BaseProject>().Where(x => x.Keys == baseEquipment.ProjectKeys).FirstAsync();
                return BllResultFactory.Success(true, $"当前SN“{sn}”绑定了“{project.ProjectName}”项目，项目编号为“{project.ProjectCode}”");
            }
            catch (Exception ex)
            {
                return BllResultFactory.Error<bool>(ex.Message);
            }
        }
    }
}