FYCore/ZhongLian/ZhongLianService/ProjectService.cs

using CommonModel;
using Dapr.Actors;
using Dapr.Actors.Client;
using Microsoft.AspNetCore.Http;
using Microsoft.Extensions.DependencyInjection;
using SqlSugar;
using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;
using ZhongLianInterface;
using ZhongLianModel;

namespace ZhongLianService
{
    /// <summary>
    /// 工程服务
    /// </summary>
    public class ProjectService : IProjectService
    {
        public ProjectService(IServiceProvider services, ISqlSugarClient sqlSugarClient)
        {
            Services = services;
            Db = sqlSugarClient;

            //创建表
            Db.CodeFirst.SetStringDefaultLength(200).InitTables(typeof(ProjectDO));
            //Db.CodeFirst.InitTables(typeof(GroupDO), typeof(CompanyDO), typeof(DeviceDO));
        }

        private readonly IServiceProvider Services;

        private readonly ISqlSugarClient Db;

        /// <summary>
        /// 插入
        /// </summary>
        /// <param name="project">工程实体</param>
        /// <returns>工程实体</returns>
        public Task<ProjectDO> Insert(ProjectDO project)
        {
            try
            {
                Db.Ado.BeginTran();
                var group = new GroupDO
                {
                    Id = Guid.NewGuid().ToString(),
                    Name = project.Name,
                    System = "ZL",
                    Type = 0,
                    PId = project.CompanyId
                };
                if (string.IsNullOrEmpty(group.Code))
                {
                    var _MaxCode = Db.Queryable<GroupDO>().MaxAsync(x => x.Code).Result;
                    if (string.IsNullOrEmpty(_MaxCode))
                    {
                        group.Code = "GP00001";
                    }
                    else
                    {
                        group.Code = $"GP{(Convert.ToInt32(_MaxCode.Substring(2, 5)) + 1).ToString().PadLeft(5, '0')}";
                    }
                }
                group.CreateDate = DateTime.Now.ToString("yyyy-MM-dd HH:mm:ss");
                group.Deleted = 0;
                Db.Insertable<GroupDO>(group).ExecuteCommand();

                project.Id = group.Id;
                if (string.IsNullOrEmpty(project.Code))
                {
                    //生成用户编号
                    var _MaxCode = Db.Queryable<ProjectDO>().MaxAsync(x => x.Code).Result;
                    if (string.IsNullOrEmpty(_MaxCode))
                    {
                        project.Code = "PJ00001";
                    }
                    else
                    {
                        project.Code = $"PJ{(Convert.ToInt32(_MaxCode.Substring(2, 5)) + 1).ToString().PadLeft(5, '0')}";
                    }
                }
                project.CreateDate = DateTime.Now.ToString("yyyy-MM-dd HH:mm:ss");
                project.Deleted = 0;
                Db.Insertable<ProjectDO>(project).ExecuteCommand();
                Db.Ado.CommitTran();
                return Task.FromResult(project);
            }
            catch
            {
                Db.Ado.RollbackTran();
                throw;
            }
        }

        /// <summary>
        /// 更新
        /// </summary>
        /// <param name="project">工程实体</param>
        /// <returns>工程实体</returns>
        public Task<ProjectDO> Update(ProjectDO project)
        {
            try
            {
                Db.Ado.BeginTran();
                Db.Updateable<GroupDO>(new GroupDO
                {
                    Id = project.Id,
                    Name = project.Name,
                    System = "ZL",
                    Type = 0,
                    PId = project.CompanyId
                }).IgnoreColumns(ignoreAllNullColumns: true).ExecuteCommand();

                Db.Updateable<ProjectDO>(project)
                .IgnoreColumns(ignoreAllNullColumns: true)
                .ExecuteCommand();

                Db.Ado.CommitTran();
                return Task.FromResult(project);
            }
            catch
            {
                Db.Ado.RollbackTran();
                throw;
            }
        }

        /// <summary>
        /// 删除
        /// </summary>
        /// <param name="Ids">Id数组</param>
        /// <returns></returns>

        public Task Delete(string[] ids)
        {
            try
            {
                Db.Ado.BeginTran();
                Db.Deleteable<GroupDO>().In(ids).ExecuteCommand();
                Db.Deleteable<ProjectDO>().In(ids).ExecuteCommand();
                Db.Ado.CommitTran();
                return Task.CompletedTask;
            }
            catch
            {
                Db.Ado.RollbackTran();
                throw;
            }
        }

        /// <summary>
        /// 根据编号查询
        /// </summary>
        /// <param name="id">编号</param>
        /// <returns>工程</returns>
        public Task<ProjectDO> Get(string id)
        {
            var result = Db.Queryable<ProjectDO>()
                .LeftJoin<CompanyDO>((a, b) => a.CompanyId == b.Id)
                .Select((a, b) => new ProjectDO
                {
                    Id = a.Id.SelectAll(),
                    CompanyName = b.Name
                }).First();
            return Task.FromResult<ProjectDO>(result);
        }

        /// <summary>
        /// 分页查询
        /// </summary>
        /// <param name="page">分页对象</param>
        /// <returns>分页对象</returns>
        public Task<PageData<ProjectDO>> List(PageSearch<ProjectDO> page)
        {
            RefAsync<int> total = 0;

            string _Search = page.Search!;


            string _Code = page.Mode!.Code!;

            string _Name = page.Mode!.Name!;

            string _CompanyId = page.Mode!.CompanyId!;

            string _Area = page.Mode!.Area!;

            string _AddressName = page.Mode!.AddressName!;

            string _CU = page.Mode!.CU!;

            string _SU = page.Mode!.SU!;

            string _PM = page.Mode!.PM!;

            var result = Db.Queryable<ProjectDO>()
                .LeftJoin<CompanyDO>((x, y) => x.CompanyId == y.Id)
                .Where(x => x.Deleted == 0)
                .WhereIF(!string.IsNullOrEmpty(_Search),
                    x => x.Name!.Contains(_Search) || x.Code!.Contains(_Search)
                )
                .WhereIF(!string.IsNullOrEmpty(_Code), x => x.Code!.Contains(_Code))
                .WhereIF(!string.IsNullOrEmpty(_Name), x => x.Name!.Contains(_Name))
                .WhereIF(!string.IsNullOrEmpty(_CompanyId), x => x.CompanyId!.Contains(_CompanyId))
                .WhereIF(!string.IsNullOrEmpty(_Area), x => x.Area!.Contains(_Area))
                .WhereIF(!string.IsNullOrEmpty(_AddressName), x => x.AddressName!.Contains(_AddressName))
                .WhereIF(!string.IsNullOrEmpty(_CU), x => x.CU!.Contains(_CU))
                .WhereIF(!string.IsNullOrEmpty(_SU), x => x.SU!.Contains(_SU))
                .WhereIF(!string.IsNullOrEmpty(_PM), x => x.PM!.Contains(_PM))
                .Select((x, y) => new ProjectDO
                {
                    Id = x.Id.SelectAll(),
                    CompanyName = y.Name
                })
                .OrderBy((x) => new { NameF = "CONVERT(Name USING GBK) ASC", x.Name })
                .ToPageListAsync(page.Index!, page.Size!, total).Result;
            return Task.FromResult(new PageData<ProjectDO>
            {
                Data = result,
                Total = total.Value
            });

        }

        /// <summary>
        /// 3D地图设备数量获取
        /// </summary>
        /// <returns></returns>
        public Task<List<GeoProjectDTO>> GeoCount()
        {
            var Province = Db.Queryable<ProjectDO>()
                .LeftJoin<DeviceDO>((x, y) => x.Id == y.ProjectId)
                .Where((x,y)=>x.Deleted == 0 && y.Deleted == 0)
                .GroupBy((x, y) => x.ProvinceCode)
                .Select((x, y) => new GeoProjectDTO
                {
                    Code = x.ProvinceCode,
                    ParentCode = "100000",
                    Count = SqlFunc.AggregateCount(y.ProjectId)
                });
            var City = Db.Queryable<ProjectDO>()
                .LeftJoin<DeviceDO>((x, y) => x.Id == y.ProjectId)
                .Where((x, y) => x.Deleted == 0 && y.Deleted == 0)
                .GroupBy((x, y) => new { x.CityCode, x.ProvinceCode })
                .Select((x, y) => new GeoProjectDTO
                {
                    Code = x.CityCode,
                    ParentCode = x.ProvinceCode,
                    Count = SqlFunc.AggregateCount(y.ProjectId)
                });
            var Area = Db.Queryable<ProjectDO>()
                .LeftJoin<DeviceDO>((x, y) => x.Id == y.ProjectId)
                .Where((x, y) => x.Deleted == 0 && y.Deleted == 0)
                .GroupBy((x, y) => new { x.AreaCode, x.CityCode })
                .Select((x, y) => new GeoProjectDTO
                {
                    Code = x.AreaCode,
                    ParentCode = x.CityCode,
                    Count = SqlFunc.AggregateCount(y.ProjectId)
                });
            return Task.FromResult(Db.Union(Province, City, Area).ToList());
        }
    }
}