tnb.server/QcMgr/Tnb.QcMgr/QcCheckItemService.cs

using System;
using System.Collections.Generic;
using System.Linq;
using System.Reflection;
using System.Text;
using System.Threading.Tasks;
using Aspose.Cells.Drawing;
using COSXML.Model.Tag;
using JNPF.Common.Core.Manager;
using JNPF.Common.Enums;
using JNPF.DependencyInjection;
using JNPF.DynamicApiController;
using JNPF.FriendlyException;
using JNPF.VisualDev;
using JNPF.VisualDev.Interfaces;
using Microsoft.AspNetCore.Identity;
using Microsoft.AspNetCore.Mvc;
using Microsoft.CodeAnalysis;
using NPOI.SS.Formula.Eval;
using NPOI.Util;
using SqlSugar;
using Tnb.Common;
using Tnb.QcMgr.Entities;
using Tnb.QcMgr.Entities.Dto;
using Tnb.QcMgr.Interfaces;

namespace Tnb.QcMgr
{
    /// <summary>
    /// 质检项清单模块
    /// </summary>
    [ApiDescriptionSettings(Tag = ModuleConsts.Tag, Area = ModuleConsts.Area, Order = 800)]
    [Route("api/[area]/[controller]/[action]")]
    [OverideVisualDev(ModuleId)]
    public class QcCheckItemService : IOverideVisualDevService, IQcCheckItemService, IDynamicApiController, ITransient
    {
        private const string ModuleId = "26500755139349";
        private readonly ISqlSugarRepository<QcCheckItemsH> _repository;
        private readonly IUserManager _userManager;
        public OverideVisualDevFunc OverideFuncs { get; } = new OverideVisualDevFunc();
        public QcCheckItemService(ISqlSugarRepository<QcCheckItemsH> repository, IUserManager userManager)
        {
            _repository = repository;
            _userManager = userManager;
            OverideFuncs.DeleteAsync = Delete;
        }

        private async Task Delete(string id)
        {
            var db = _repository.AsSugarClient();
            var QcCheckItemsH=await db.Queryable< QcCheckItemsH >().Where(p=>p.id==id).FirstAsync();
            var QcCheckItemsRs = await db.Queryable<QcCheckItemsR>().Where(p => p.itemshid == id).ToListAsync() ;
            var QcCheckItemsDs=await db.Queryable<QcCheckItemsD>().Where(p=> QcCheckItemsRs.Select(p=>p.id).ToList().Contains( p.id)).ToListAsync() ;
            await db.Ado.BeginTranAsync();
            await db.Deleteable(QcCheckItemsH).ExecuteCommandAsync();
            await db.Deleteable(QcCheckItemsRs).ExecuteCommandAsync();
            await db.Deleteable(QcCheckItemsDs).ExecuteCommandAsync();
            await db.Ado.CommitTranAsync();
        }

        /// <summary>
        /// 获取质检项集合
        /// </summary>
        /// <returns></returns>
        [HttpGet]
        public async Task<dynamic> GetCheckItem()
        {
            var db = _repository.AsSugarClient();
            List<CheckItemOut> CheckItemOuts = new List<CheckItemOut>();
            var datas = await db.Queryable<QcCheckItem>().InnerJoin<QcCheckType>((a, b) => a.type == b.id).Select((a, b) => new
            {
                id = a.id,
                name = a.name,
                code = a.code,
                type = a.type,
                typename = b.name
            }).ToListAsync();
            foreach (var data in datas)
            {
                if (CheckItemOuts.Where(p => p.checktypeid == data.type).Any())
                {
                    var CheckItemOut = CheckItemOuts.Where(p => p.checktypeid == data.type).First();
                    if (CheckItemOut.items == null)
                    {
                        CheckItemOut.items = new List<CheckItem>();
                        CheckItemOut.items.Add(new CheckItem { itemid = data.id, name = data.name, code = data.code });
                    }
                    else
                        CheckItemOut.items.Add(new CheckItem { itemid = data.id, name = data.name, code = data.code });
                }
                else
                {
                    CheckItemOuts.Add(new CheckItemOut { checktypeid = data.type, checktypename = data.typename, items = new List<CheckItem>() });
                    var CheckItemOut = CheckItemOuts.Where(p => p.checktypeid == data.type).First();
                    CheckItemOut.items.Add(new CheckItem() { itemid = data.id, name = data.name, code = data.code });
                }
            }
            return CheckItemOuts;
        }

        /// <summary>
        /// 保存质检项清单
        /// </summary>
        /// <param name="CheckItemInput"></param>
        /// <returns></returns>
        [HttpPost]
        public async Task SaveData(CheckItemsInput CheckItemsInput)
        {
            var db = _repository.AsSugarClient();
            try
            {
            
                QcCheckItemsH QcCheckItemsH = new QcCheckItemsH();
                QcCheckItemsH.name = CheckItemsInput.name;
                QcCheckItemsH.status = CheckItemsInput.status;
                QcCheckItemsH.create_time = DateTime.Now;
                QcCheckItemsH.create_id = _userManager.UserId;
                List<QcCheckItemsR> QcCheckItemsRs = new List<QcCheckItemsR>();
                List<QcCheckItemsD> QcCheckItemsDs = new List<QcCheckItemsD>();

                foreach (var checktype in CheckItemsInput.checktypoes)
                {
                    foreach (var item in checktype.items)
                    {
                        var QcCheckItemsD = new QcCheckItemsD()
                        {
                            extype = item.extype,
                            excontent = item.excontent,
                            check = item.check,
                            errorcause = item.errorcause,
                            errorlevel = item.errorlevel,
                            remark = item.remark,
                            attachment = item.attachment,
                            isexec = item.isexec
                        };
                        QcCheckItemsDs.Add(QcCheckItemsD);
                        var QcCheckItemsR = new QcCheckItemsR()
                        {
                            itemshid = QcCheckItemsH.id,
                            typeid = checktype.id,
                            itemid = item.itemid,
                            itemsdid = QcCheckItemsD.id
                        };

                        QcCheckItemsRs.Add(QcCheckItemsR);
                    }
                }
                await db.Ado.BeginTranAsync();
                await db.Insertable(QcCheckItemsH).ExecuteCommandAsync();
                await db.Insertable(QcCheckItemsRs).ExecuteCommandAsync();
                await db.Insertable(QcCheckItemsDs).ExecuteCommandAsync();
                await db.Ado.CommitTranAsync();
            }
            catch (Exception ex)
            {  
                await db.Ado.RollbackTranAsync();
                throw Oops.Oh(ErrorCode.COM1000);
            }
        }
    }
}