tnb.server/QcMgr/Tnb.QcMgr/QcCheckTaskService.cs

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;
using Aspose.Cells.Drawing;
using JNPF.Common.Core.Manager;
using JNPF.Common.Enums;
using JNPF.DependencyInjection;
using JNPF.DynamicApiController;
using JNPF.FriendlyException;
using JNPF.JsonSerialization;
using JNPF.Systems.Entitys.Permission;
using Microsoft.AspNetCore.Identity;
using Microsoft.AspNetCore.Mvc;
using SqlSugar;
using Tnb.QcMgr.Entities;
using Tnb.QcMgr.Entities.Dto;
using Tnb.QcMgr.Entities.Entity;
using Tnb.QcMgr.Interfaces;

namespace Tnb.QcMgr
{
    /// <summary>
    /// 质检任务模块
    /// </summary>
    [ApiDescriptionSettings(Tag = ModuleConsts.Tag, Area = ModuleConsts.Area, Order = 800)]
    [Route("api/[area]/[controller]/[action]")]
    public class QcCheckTaskService : IQcCheckTaskService, IDynamicApiController, ITransient
    {
        private readonly ISqlSugarRepository<QcCheckExecH> _repository;
        private readonly IUserManager _userManager;
        public QcCheckTaskService(ISqlSugarRepository<QcCheckExecH> repository, IUserManager userManager)
        {
            _repository = repository;
            _userManager = userManager;
        }
        /// <summary>
        /// 获取任务执行明细
        /// </summary>
        /// <param name="id"></param>
        /// <returns></returns>
        [HttpGet]
        public async Task<dynamic> GetTaskItems(string id)
        {
            var db = _repository.AsSugarClient();
   
            string planid = "26813180898837";
            var lists=  await db.Queryable<QcCheckExecD>().Where(p => p.mainid == id).ToListAsync();
            if (lists.Count == 0)
            {
                var QcCheckPlanDs = await db.Queryable<QcCheckPlanD>().Where(p => p.mainid == planid).ToListAsync();
                List<QcCheckExecD> NewQcCheckExecDs = new List<QcCheckExecD>();
                foreach (var QcCheckPlanD in QcCheckPlanDs)
                {
                    QcCheckExecD QcCheckExecD = new QcCheckExecD();
                    QcCheckExecD.mainid = id;
                    QcCheckExecD.extype = QcCheckPlanD.extype;
                    QcCheckExecD.excontent = QcCheckPlanD.excontent;
                    QcCheckExecD.check = QcCheckPlanD.check;
                    QcCheckExecD.errorcause = QcCheckPlanD.errorcause;
                    QcCheckExecD.errorlevel = QcCheckPlanD.errorlevel;
                    QcCheckExecD.remark = QcCheckPlanD.remark;
                    QcCheckExecD.attachment = QcCheckPlanD.attachment;
                    QcCheckExecD.isexec = QcCheckPlanD.isexec;
                    QcCheckExecD.custom = QcCheckPlanD.custom;
                    QcCheckExecD.typeid = QcCheckPlanD.typeid;
                    QcCheckExecD.itemid = QcCheckPlanD.itemid;
                    NewQcCheckExecDs.Add(QcCheckExecD);
                }
                await db.Insertable<QcCheckExecD>(NewQcCheckExecDs).ExecuteCommandAsync();
            }
            var QcCheckExecH = await db.Queryable<QcCheckExecH>().Where(p => p.id == id).FirstAsync();
            var QcCheckExecDs = await db.Queryable<QcCheckExecD>().Where(p => p.mainid == id).ToListAsync();
            var QcCheckItems = await db.Queryable<QcCheckItem>().ToListAsync();
            var QcCheckTypes = await db.Queryable<QcCheckType>().ToListAsync();
            var QcErrorCauses = await db.Queryable<QcErrorCause>().ToListAsync();
            var QcErrorLevels = await db.Queryable<QcErrorLevel>().ToListAsync();

            CheckTaskOut CheckTaskOut = new CheckTaskOut();
            CheckTaskOut.mainid = id;
            CheckTaskOut.wareid = QcCheckExecH.wareid!;
            CheckTaskOut.workid = QcCheckExecH.workid!;
            if (!string.IsNullOrEmpty(CheckTaskOut.workid))
                CheckTaskOut.workname = db.Queryable<OrganizeEntity>().Where(p => p.Id == CheckTaskOut.workid).First().FullName;
            CheckTaskOut.checktypes = new List<CheckExecTypeOut>();
            foreach (var QcCheckExecD in QcCheckExecDs)
            {
                if (CheckTaskOut.checktypes.Where(p => p.checktypeid == QcCheckExecD.typeid).ToList().Count == 0)
                {
                    CheckExecTypeOut checkType = new CheckExecTypeOut();
                    checkType.checktypeid = QcCheckExecD.typeid!;
                    checkType.checktypename = QcCheckTypes.Where(p => p.id == QcCheckExecD.typeid).First().name!;
                    checkType.items = new List<ExecItemOut>();
                    CheckTaskOut.checktypes.Add(checkType);
                }
                ExecItemOut Item = new ExecItemOut();
                Item.itemid = QcCheckExecD.itemid!;
                Item.itemdid = QcCheckExecD.id!;
                Item.code = QcCheckItems.Where(p => p.id == QcCheckExecD.itemid).First().code!;
                Item.name = QcCheckItems.Where(p => p.id == QcCheckExecD.itemid).First().name!;
                Item.setData = new ExecItemData();
                Item.setData.extype = QcCheckExecD.extype!;
                Item.setData.excontent = JSON.Deserialize<Excontent>(QcCheckExecD.excontent!); 
                Item.setData.check = QcCheckExecD.check!;
                if (!string.IsNullOrEmpty(QcCheckExecD.errorcause))
                {
                    var strs = QcCheckExecD.errorcause!.Replace("[", "").Replace("]", "").Split(',', StringSplitOptions.RemoveEmptyEntries);
                    Item.setData.errorcause = new List<Error>();
                    foreach (var str in strs)
                    {
                        Item.setData.errorcause.Add(new Error { id = str, name = QcErrorCauses.Where(p => p.id == str).First().name! });
                    }
                }
                if (!string.IsNullOrEmpty(QcCheckExecD.errorlevel))
                {
                    var strs = QcCheckExecD.errorlevel!.Replace("[", "").Replace("]", "").Split(',', StringSplitOptions.RemoveEmptyEntries);
                    Item.setData.errorlevel = new List<Error>();
                    foreach (var str in strs)
                    {
                        Item.setData.errorlevel.Add(new Error { id = str, name = QcErrorLevels.Where(p => p.id == str).First().name! });
                    }
                }
                Item.setData.remark = QcCheckExecD.remark!;
                Item.setData.attachment = QcCheckExecD.attachment!;
                Item.setData.customer = QcCheckExecD.custom!;
                if (!string.IsNullOrEmpty(QcCheckExecD.isexec))
                    Item.setData.isexec = JSON.Deserialize<IsexecE>(QcCheckExecD.isexec!);
                Item.setShow = new ExecItemShow();
                Item.setShow.extype = !string.IsNullOrEmpty(Item.setData.extype);
                Item.setShow.excontent = !string.IsNullOrEmpty(QcCheckExecD.excontent);
                Item.setShow.check = !string.IsNullOrEmpty(Item.setData.check);
                Item.setShow.errorcause = Item.setData.errorcause.Count == 0 ? false : true;
                Item.setShow.errorlevel = Item.setData.errorlevel.Count == 0 ? false : true;
                Item.setShow.remark = !string.IsNullOrEmpty(Item.setData.remark);
                Item.setShow.attachment = !string.IsNullOrEmpty(Item.setData.attachment);
                Item.setShow.customer = !string.IsNullOrEmpty(Item.setData.customer);
                Item.setShow.isexec = Item.setData.isexec == null ? false : true;
                CheckTaskOut.checktypes.Where(p => p.checktypeid == QcCheckExecD.typeid).First().items.Add(Item);
            }
            return CheckTaskOut;
        }

        /// <summary>
        /// 执行任务
        /// </summary>
        /// <param name="CheckTaskInput"></param>
        /// <returns></returns>
        [HttpPost]
        public async Task SaveData(CheckTaskInput CheckTaskInput)
        {
            var db = _repository.AsSugarClient();
            try
            {
                var QcCheckExecH = await db.Queryable<QcCheckExecH>().Where(p => p.id == CheckTaskInput.mainid).FirstAsync();
                QcCheckExecH.checknum = CheckTaskInput.checknum;
                QcCheckExecH.status = CheckTaskInput.status;
                QcCheckExecH.result = CheckTaskInput.result;
                QcCheckExecH.execuser = _userManager.UserId;
                QcCheckExecH.exectime = DateTime.Now.ToString();
                var QcCheckExecDs = await db.Queryable<QcCheckExecD>().Where(p => p.mainid == CheckTaskInput.mainid).ToListAsync();
                foreach (var checktype in CheckTaskInput.checktypes)
                {
                    foreach (var item in checktype.items)
                    {
                        var QcCheckExecD = QcCheckExecDs.Where(p => p.id == item.itemdid).FirstOrDefault();
                        if (QcCheckExecD == null)
                            continue;
                        QcCheckExecD.excontent = item.excontent;
                        QcCheckExecD.check = item.check;
                        QcCheckExecD.errorcause = item.errorcause;
                        QcCheckExecD.errorlevel = item.errorlevel;
                        QcCheckExecD.remark = item.remark;
                        QcCheckExecD.attachment = item.attachment;
                        QcCheckExecD.isexec = item.isexec;
                        QcCheckExecD.custom = item.customer;
                        QcCheckExecD.result = item.result;
                    }
                }
                await db.Ado.BeginTranAsync();
                await db.Updateable(QcCheckExecH).ExecuteCommandAsync();
                await db.Updateable(QcCheckExecDs).ExecuteCommandAsync();
                await db.Ado.CommitTranAsync();
            }
            catch (Exception ex)
            {
      
                throw Oops.Oh(ErrorCode.COM1000);
            }
        }
    }
}