zhuangpei-mesbackend/DOAN.Service/Mobile/PADReportWorkService.cs

using DOAN.Model;
using DOAN.Model.MES.base_;
using DOAN.Model.MES.mm;
using DOAN.Model.MES.product;
using DOAN.Model.MES.product.Dto;
using DOAN.Repository;
using DOAN.Service.Mobile.IService;
using Infrastructure.Attribute;


namespace DOAN.Service.Mobile
{
    [AppService(ServiceType = typeof(IPADReportWorkService), ServiceLifetime = LifeTime.Transient)]
    public class PADReportWorkService : BaseService<ProReportwork>, IPADReportWorkService
    {
        /// <summary>
        /// 不防错直接报工
        /// </summary>
        /// <param name="wokorder"></param>
        /// <param name="reportNum"></param>
        /// <returns></returns>
        public int NoErrorProofingAndReportingReport(string wokorder, int reportNum)
        {
            int result = 0;


            var selected_workorder = Context.Queryable<ProReportwork>().Where(it => it.FkWorkorder == wokorder)
                .First();
            if (selected_workorder != null)
            {
                //修改
                result = Context.Updateable<ProReportwork>().Where(it => it.FkWorkorder == wokorder)
                    .SetColumns(it => it.FinishedNum == reportNum)
                    .SetColumns(it => it.UpdatedTime == DateTime.Now)
                    .SetColumns(it => it.UpdatedBy == "PDA")
                    .ExecuteCommand();
            }
            else
            {
                //新增
                var  handle_workorder=  Context.Queryable<ProWorkorder>().Where(it => it.Workorder == wokorder).First();
                var reportWork = new ProReportwork();
                reportWork.Id = XueHua;
                reportWork.FkWorkorder = wokorder;
                reportWork.DispatchNum = handle_workorder.DeliveryNum;
                reportWork.FinishedNum = reportNum;
                reportWork.GroupCode = handle_workorder.GroupCode;
                reportWork.LineCode = handle_workorder.LineCode;
                reportWork.CreatedTime = DateTime.Now;
                reportWork.CreatedBy = "PDA";
              
                result = Context.Insertable(reportWork).ExecuteCommand();
            }

          


            return result;
        }

        public List<BaseWorkRoute> GetAllRoute()
        {
            return Context.Queryable<BaseWorkRoute>().ToList();
        }

        public List<BaseGroup> GetGroupList()
        {
            return Context.Queryable<BaseGroup>().Where(it => it.Status == 1).ToList();
        }

        public ProWorkorderDto4 GetWorkOrderDetail(string workorder)
        {
            var query = Context.Queryable<ProWorkorder>()
                .Where(it => it.Workorder == workorder);


            return Context.Queryable(query)
                .LeftJoin<ProReportwork>((q, r) => q.Workorder == r.FkWorkorder)
                .Select((q, r) => new ProWorkorderDto4
                {
                    FinishNum = r.FinishedNum
                }, true).First();
        }

        public List<ProReportworkDto> GetWorkOrderStatusList(string group_code, int status, DateTime handleDate)
        {
            var query = Context.Queryable<ProWorkorder>().Where(it => it.GroupCode == group_code)
                .Where(it => it.Status == status)
                .Where(it => it.WorkorderDate == handleDate);

            return Context.Queryable(query)
                .LeftJoin<ProReportwork>((w, r) => w.Workorder == r.FkWorkorder)
                .Select((w, r) => new ProReportworkDto
                {
                    Id = r.Id,
                    ProductionCode = w.ProductionCode,
                    ProductionName = w.ProductionName,
                    Specification = w.Specification,
                    QualifiedNumber = r.QualifiedNumber,
                    UnqualifiedNumber = r.UnqualifiedNumber,
                    ReworkNumber = r.ReworkNumber,
                    ScrapNumber = r.ScrapNumber,
                    Remark = r.Remark,
                    Difference = r.QualifiedNumber - r.FinishedNum ?? 0,
                    FkWorkorder = w.Workorder,
                    GroupCode = w.GroupCode,
                    LineCode = w.LineCode,
                    DispatchNum = w.DeliveryNum ?? 0,
                    Priority = w.Priority,
                    Status = w.Status,
                    Beat = w.Beat
                }, true).ToList();
        }


        /// <summary>
        /// 修改报工表
        /// </summary>
        /// <param name="model"></param>
        /// <returns></returns>
        public int UpdateProReportwork(ProReportwork model)
        {


            //var response = Update(w => w.Id == model.Id, it => new ProReportwork()
            //{
            //    FkWorkorder = model.FkWorkorder,
            //    DispatchNum = model.DispatchNum,
            //    FinishedNum = model.FinishedNum,
            //    GroupCode = model.GroupCode,
            //    LineCode = model.LineCode,
            //    CreatedBy = model.CreatedBy,
            //    CreatedTime = model.CreatedTime,
            //    UpdatedBy = model.UpdatedBy,
            //    UpdatedTime = model.UpdatedTime,
            //});
            //return response;
            return Update(model, true);
        }

        public int StartWorkOrder(string workorder)
        {
            var result = 0;
            // 获取同一天 同一组 同一线 的所有工单 把状态2 设为init 1
            var handleWorkorder =
                Context.Queryable<ProWorkorder>().Where(it => it.Workorder == workorder).First();
            UseTran2(() =>
            {
                Context.Updateable<ProWorkorder>().SetColumns(it => it.Status == 1)
                    .Where(it => it.Status == 2)
                    .Where(it => it.WorkorderDate == handleWorkorder.WorkorderDate)
                    .Where(it => it.GroupCode == handleWorkorder.GroupCode)
                    .Where(it => it.LineCode == handleWorkorder.LineCode)
                    .ExecuteCommand();


                result = Context.Updateable<ProWorkorder>().SetColumns(it => it.Status == 2)
                    .SetColumns(it => it.StartTime == DateTime.Now)
                    .Where(it => it.Workorder == workorder).ExecuteCommand();
            });
            return result;
        }

        public int FinishWorkOrder(string workorder)
        {
            return Context.Updateable<ProWorkorder>()
                .SetColumns(it => it.Status == 3)
                .SetColumns(it => it.EndTime == DateTime.Now)
                .Where(it => it.Workorder == workorder).ExecuteCommand();
        }


        /// <summary>
        /// 查询报工表列表
        /// </summary>
        /// <param name="parm"></param>
        /// <returns></returns>
        public PagedInfo<ProReportworkDto> GetList(ProReportworkQueryDto parm)
        {
            if (parm.TimeRange != null && parm.TimeRange.Length == 2)
            {
                parm.TimeRange[0] = parm.TimeRange[0].Date;
                // parm.TimeRange[1] = parm.TimeRange[1].Date.AddDays(1);
                parm.TimeRange[1] = parm.TimeRange[1].Date;
            }

            var predicate = Expressionable.Create<ProWorkorder, ProReportwork>()
                    .AndIF(!string.IsNullOrEmpty(parm.FkWorkorder), (w, r) => w.Workorder.Contains(parm.FkWorkorder))
                    .AndIF(!string.IsNullOrEmpty(parm.GroupCode), (w, r) => w.GroupCode == parm.GroupCode)
                    .AndIF(!string.IsNullOrEmpty(parm.LineCode), (w, r) => w.LineCode == parm.LineCode)
                    .AndIF(parm.WarehouseconfirmationNum > 0, (w, r) => r.QualifiedNumber > 0)
                    .AndIF(
                        parm.TimeRange != null && parm.TimeRange.Length == 2 && parm.TimeRange[0] > DateTime.MinValue,
                        (w, r) => w.WorkorderDate >= parm.TimeRange[0])
                    .AndIF(
                        parm.TimeRange != null && parm.TimeRange.Length == 2 && parm.TimeRange[1] > DateTime.MinValue,
                        (w, r) => w.WorkorderDate <= parm.TimeRange[1])
                    .AndIF(parm.Status > 0, (w, r) => w.Status == parm.Status)
                ;


            var response = Context.Queryable<ProWorkorder>()
                .LeftJoin<ProReportwork>((w, r) => w.Workorder == r.FkWorkorder)
                .Where(predicate.ToExpression())
                .Select((w, r) => new ProReportworkDto
                {
                    Id = r.Id,
                    ProductionCode = w.ProductionCode,
                    ProductionName = w.ProductionName,
                    Specification = w.Specification,
                    QualifiedNumber = r.QualifiedNumber,
                    UnqualifiedNumber = r.UnqualifiedNumber,
                    ReworkNumber = r.ReworkNumber,
                    ScrapNumber = r.ScrapNumber,
                    Remark = r.Remark,
                    Difference = r.QualifiedNumber - r.FinishedNum ?? 0,
                    FkWorkorder = w.Workorder,
                    GroupCode = w.GroupCode,
                    LineCode = w.LineCode,
                    DispatchNum = w.DeliveryNum ?? 0,
                    Priority = w.Priority,
                    Status = w.Status,
                    Beat = w.Beat
                }, true).ToPage_NO_Convert<ProReportworkDto>(parm);

            return response;
        }




      
    }
}