高翔 / ECS-ZJHX · Files



using FreeSql;
using HHECS.Application.Enums;
using HHECS.Application.Error;
using HHECS.BllModel;
using HHECS.Dal;
using HHECS.Dal.Repository;
using HHECS.DAL.Repository;
using HHECS.Infrastructure.CommonHelper;
using HHECS.Infrastructure.Enums;
using HHECS.Model.Entities;
using HHECS.Model.Enums.Task;
using System;
using System.Collections.Generic;
using System.Linq;
using System.Linq.Expressions;

namespace HHECS.Application.Service
{
    public class TaskService : BaseService
    {
        private readonly LogService logService = new LogService();
        private readonly LocationService locationService = new LocationService();

        public static object LockObject { get; set; } = new object();

        /// <summary>
        /// 记录任务流转
        /// </summary>
        /// <param name="taskId"></param>
        /// <param name="equipment"></param>
        /// <param name="msg"></param>
        /// <returns></returns>
        /// <exception cref="NotImplementedException"></exception>
        public BllResult RecordTask(int taskId, Equipment equipment, string msg)
        {
            try
            {
                //TaskExecuteRecordRepository taskExecuteRecordRepository = new TaskExecuteRecordRepository();
                //TaskExecuteRecord taskExecuteRecord = new TaskExecuteRecord()
                //{
                //    TaskId = taskId,
                //    EquipmentCode = equipment.Code,
                //    EquipmentName = equipment.Name,
                //    Description = msg,
                //    Created = DateTime.Now,
                //};
                //taskExecuteRecordRepository.InsertOrUpdate(taskExecuteRecord);
                return BllResultFactory.Success();
            }
            catch (Exception ex)
            {
                return BllResultFactory.Error(ex.Message, ErrorCodeConst.DEZ0001.ToString());
            }
        }

        /// <summary>
        /// 更改小车任务目标库位
        /// </summary>
        /// <param name="id">任务id</param>
        /// <param name="toLocation">修改后的目标库位数据</param>
        /// <returns></returns>
        public BllResult UpdateTaskCarToLocation(int id, string toLocationCode, string userCode)
        {
            try
            {
                var taskCarEntityRepository = new BusTaskTrussRepository();
                var task = taskCarEntityRepository.Where(t => t.Id == id).First();
                if (task == null)
                {
                    return BllResultFactory.Error($"未找到任务：{id};");
                }
                var oldTolocation = task.ToStationCode;
                task.ToStationCode = oldTolocation;
                task.UpdateTime = DateTime.Now;
                task.UpdateBy = userCode;
                taskCarEntityRepository.Update(task);
                logService.LogOperation(Title.TaskMaintain, ModuleConst.Task, $"更改目标库位：任务号{id},原目标库位{oldTolocation}改为{toLocationCode}成功", Level.Success.ToString(), userCode);
                return BllResultFactory.Success();

            }

            catch (Exception ex)
            {
                logService.LogOperation(Title.TaskMaintain, ModuleConst.Task, $"更改目标库位：任务号{id},原目标库位改为{toLocationCode}异常：{ex}", Level.Exception.ToString(), userCode);

                return BllResultFactory.Error($"异常:{ex}");
            }

        }

        /// <summary>
        /// 更改小车源库位数据，不再做限制，只记录日志
        /// </summary>
        /// <param name="id"></param>
        /// <param name="fromLocation"></param>
        /// <returns></returns>
        public BllResult UpdateTaskCarFromLocationCode(int id, int fromLocationCode, string userCode)
        {
            try
            {
                var taskCarEntityRepository = new BusTaskTrussRepository();
                var task = taskCarEntityRepository.Where(t => t.Id == id).First();
                if (task == null)
                {
                    return BllResultFactory.Error($"未找到任务：{id}");
                }
                //直接更新
                var oldFromlocation = task.FromStationCode;
                task.FromStationCode = fromLocationCode.ToString();
                task.UpdateTime = DateTime.Now;
                task.UpdateBy = userCode;
                taskCarEntityRepository.Update(task);

                logService.LogOperation(Title.TaskMaintain, ModuleConst.Task, $"更改源库位：任务号{id},原源库位{oldFromlocation}改为{fromLocationCode}成功", Level.Success.ToString(), userCode);
                return BllResultFactory.Success();
            }
            catch (Exception ex)
            {
                logService.LogOperation(Title.TaskMaintain, ModuleConst.Task, $"更改源库位：任务号{id},原源库位改为{fromLocationCode}失败,{ex}", Level.Exception.ToString(), userCode);
                return BllResultFactory.Error($"异常：{ex}");
            }
        }

        /// <summary>
        /// 维护小车任务状态
        /// </summary>
        /// <param name="value"></param>
        /// <param name="userCode"></param>
        /// <returns></returns>
        public BllResult ChangeTaskCarStatus(int id, int status, string userCode)
        {
            try
            {
                using (var uw = DALHelper.GetFreeSql().CreateUnitOfWork())
                {
                    var taskCarEntityRepository = new CutPlanHeadRepository();
                    taskCarEntityRepository.UnitOfWork = uw;
                    var task = taskCarEntityRepository.Where(t => t.Id == id).First();
                    if (task == null)
                    {
                        return BllResultFactory.Error($"未能获取到任务：{id},请核对任务数据");
                    }
                    var temp = task.State;
                    task.State = status;
                    task.UpdateTime = DateTime.Now;
                    task.UpdateBy = userCode;
                    var result = taskCarEntityRepository.Update(task);
                    if (result > 0)
                    {
                        uw.Commit();
                        logService.LogOperation(Title.TaskMaintain, ModuleConst.Task, $"更改任务号{id},原状态{temp}改为{status}成功", Level.Success.ToString(), userCode);
                        return BllResultFactory.Success("更改状态成功");
                    }
                    else
                    {
                        uw.Rollback();
                        logService.LogOperation(Title.TaskMaintain, ModuleConst.Task, $"更改任务号{id},原状态{temp}改为{status}失败：", Level.Failure.ToString(), userCode);
                        return BllResultFactory.Error($"更改状态失败：");
                    }
                }

            }
            catch (Exception ex)
            {
                logService.LogOperation(Title.TaskMaintain, ModuleConst.Task, $"更改任务号{id},原状态改为{status}异常：{ex}", Level.Failure.ToString(), userCode);
                return BllResultFactory.Error($"更改状态异常：{ex.Message}");
            }
        }


        public BllResult<List<CutPlanHead>> GetTaskCar(Expression<Func<CutPlanHead, bool>> filter, int pageIndex, int pageSize, out long totalCount)
        {
            try
            {
                CutPlanHeadRepository taskTrussEntityRepository = new CutPlanHeadRepository();
                var result = taskTrussEntityRepository.Where(filter).Count(out totalCount).Page(pageIndex, pageSize).ToList();
                return BllResultFactory.Success(result);
            }
            catch (Exception ex)
            {
                totalCount = 0;
                return BllResultFactory.Error<List<CutPlanHead>>(ex.Message, ErrorCodeConst.DEZ0001.ToString());
            }
        }

        public BllResult DeleteTaskCars(List<CutPlanHead> taskTrussEntities)
        {
            using (var uw = DALHelper.GetFreeSql().CreateUnitOfWork())
            {
                try
                {
                    CutPlanHeadRepository taskTrussEntityRepository = new CutPlanHeadRepository();
                    taskTrussEntityRepository.UnitOfWork = uw;
                    taskTrussEntityRepository.Delete(taskTrussEntities);
                    uw.Commit();
                    return BllResultFactory.Success();
                }
                catch (Exception ex)
                {
                    uw?.Rollback();
                    return BllResultFactory.Error($"异常：{ex.Message}", ErrorCodeConst.DEZ0001.ToString());
                }
            }
        }


        public BllResult<List<BaseWorkStation>> GetStations(Expression<Func<BaseWorkStation, bool>> filter)
        {
            try
            {
                BaseWorkStationRepository baseWorkStationRepository = new BaseWorkStationRepository();
                return BllResultFactory.Success(baseWorkStationRepository.Where(filter).ToList());
            }
            catch (Exception ex)
            {
                return BllResultFactory.Error<List<BaseWorkStation>>($"异常：{ex.Message}", ErrorCodeConst.DEZ0001.ToString());
            }
        }

        public BllResult<List<Equipment>> GetEquipments(Expression<Func<Equipment, bool>> filter)
        {
            try
            {
                EquipmentRepository equipmentRepository = new EquipmentRepository();
                return BllResultFactory.Success(equipmentRepository.Where(filter).ToList());
            }
            catch (Exception ex)
            {
                return BllResultFactory.Error<List<Equipment>>($"异常：{ex.Message}", ErrorCodeConst.DEZ0001.ToString());
            }
        }

        public BllResult<List<BaseProcessRouteDetail>> GetProcessRouteDetails(Expression<Func<BaseProcessRouteHead, bool>> filter)
        {
            try
            {
                BaseProcessRouteDetailRepository processRouteDetailRepository = new BaseProcessRouteDetailRepository();
                BaseProcessRouteHeadRepository processRouteHeadRepository = new BaseProcessRouteHeadRepository();
                var processRouteHead = processRouteHeadRepository.Where(filter).First();
                if (processRouteHead == null)
                {
                    return BllResultFactory.Error<List<BaseProcessRouteDetail>>($"产品编码为空", ErrorCodeConst.QEZ0001.ToString());

                }
                return BllResultFactory.Success(processRouteDetailRepository.Where(t => t.Headkeys == processRouteHead.Keys).ToList());
            }
            catch (Exception ex)
            {
                return BllResultFactory.Error<List<BaseProcessRouteDetail>>($"异常：{ex.Message}", ErrorCodeConst.DEZ0001.ToString());
            }
        }

        public BllResult<List<Line>> GetLines(Expression<Func<Line, bool>> filter)
        {
            try
            {
                BaseLineRepository lineRepository = new BaseLineRepository();
                return BllResultFactory.Success(lineRepository.Where(filter).ToList());
            }
            catch (Exception ex)
            {
                return BllResultFactory.Error<List<Line>>($"异常：{ex.Message}", ErrorCodeConst.DEZ0001.ToString());
            }
        }



        /// <summary>
        /// 分页查询 获取所有任务信息
        /// </summary>
        /// <returns></returns>
        public BllResult<List<BaseStepTrace>> GetAllStepTraces(Expression<Func<BaseStepTrace, bool>> exp, int pageIndex, int pageSize, out long totalCount, string orderBy = null)
        {
            var stepTraceRepository = new BaseStepTraceRepository();
            if (orderBy?.Length > 0)
            {
                return BllResultFactory.Success(stepTraceRepository.Where(exp).Count(out totalCount).OrderBy(orderBy).Page(pageIndex, pageSize).ToList());
            }
            return BllResultFactory.Success(stepTraceRepository.Where(exp).Count(out totalCount).Page(pageIndex, pageSize).ToList());
        }


        /// <summary>
        /// 分页查询 获取所有任务信息
        /// </summary>
        /// <returns></returns>
        public BllResult<List<CutPlanDetail>> GetAllCutPlanTasks(Expression<Func<CutPlanDetail, bool>> exp, int pageIndex, int pageSize, out long totalCount, string orderBy = null)
        {
            try
            {
                return BllResultFactory.Success(new CutPlanDetailRepository().Where(exp).Count(out totalCount).OrderByDescending(a => a.CreateTime).Page(pageIndex, pageSize).ToList());

            }
            catch (Exception ex)
            {
                totalCount = 0;
                return BllResultFactory.Error<List<CutPlanDetail>>(ex.Message, ErrorCodeConst.DEZ0001.ToString());
            }
        }


        public BllResult<List<CutPlanTask>> GetAllCutPlanTasks(Expression<Func<CutPlanTask, bool>> filter, int pageIndex, int pageSize, out long totalCount)
        {
            try
            {
                var cutPlanTaskRepository = new CutPlanTaskRepository();
                var result = cutPlanTaskRepository.Where(filter).Count(out totalCount).Page(pageIndex, pageSize).ToList();
                return BllResultFactory.Success(result);
            }
            catch (Exception ex)
            {
                totalCount = 0;
                return BllResultFactory.Error<List<CutPlanTask>>($"异常：{ex.Message}", ErrorCodeConst.DEZ0001.ToString().ToString());
            }
        }


        /// <summary>
        /// 强制完成在制品
        /// </summary>
        /// <param name="stepTraceId"></param>
        /// <param name="userCode"></param>
        /// <returns></returns>
        public BllResult StepTraceExceptionOver(int stepTraceId, string userCode)
        {
            IRepositoryUnitOfWork uw = null;
            try
            {
                var stepTraceRepository = new BaseStepTraceRepository();
                var stepTrace = stepTraceRepository.Where(t => t.Id == stepTraceId).First();
                if (stepTrace == null)
                {
                    return BllResultFactory.Error($"在制品【{stepTraceId}】不存在！");
                }
                if (stepTrace.Status >= StepTraceStatus.生产完成.GetIndexInt())
                {
                    return BllResultFactory.Error($"在制品【{stepTraceId}】已经完成，不能修改数据");
                }
                stepTrace.Status = StepTraceStatus.强制完成.GetIndexInt();
                stepTrace.UpdateTime = DateTime.Now;
                stepTrace.UpdateBy = userCode;
                var stepTraceLogRepository = new StepTraceLogRepository();
                var taskTrussEntityRepository = new BusTaskTrussRepository();
                var taskTrusss = taskTrussEntityRepository.Where(u => u.StepTraceId == stepTrace.Id).ToList();
                foreach (var taskTruss in taskTrusss)
                {
                    if (taskTruss.Status >= (int)TaskTrussStatus.ResponsePutCompleted)
                    {
                        continue;
                    }
                    taskTruss.Status = (int)TaskTrussStatus.TaskErrorCompleted;

                }
                //开启事务，开始执行数据库更新操作
                uw = DALHelper.GetFreeSql().CreateUnitOfWork();
                stepTraceRepository.UnitOfWork = uw;
                taskTrussEntityRepository.UnitOfWork = uw;
                if (taskTrusss != null)
                {
                    taskTrussEntityRepository.Update(taskTrusss);
                }
                stepTraceRepository.Update(stepTrace);
                uw?.Commit();
                uw?.Dispose();

                return BllResultFactory.Success($"在制品【{stepTraceId}】的状态更新为【{StepTraceStatus.强制完成}】成功！");
            }
            catch (Exception ex)
            {
                uw?.Rollback();
                uw?.Dispose();
                return BllResultFactory.Exception(ex, $"在制品【{stepTraceId}】状态更新为【{StepTraceStatus.强制完成}】的时候，发生异常：{ex.Message}");
            }
        }


        /// <summary>
        /// 强制完成在制品
        /// </summary>
        /// <param name="stepTraceId"></param>
        /// <param name="userCode"></param>
        /// <returns></returns>
        public BllResult CutTaskExceptionOver(List<CutPlanDetail> cutPlanTasks, string userCode)
        {
            IRepositoryUnitOfWork uw = null;
            try
            {
                var buswork = new BusWorkOrderDetailRepository();
                var cutPlanTaskRepository = new CutPlanDetailRepository();
                var ids = cutPlanTasks.Select(x => x.Id).ToList();
                cutPlanTasks = cutPlanTaskRepository.Where(t => ids.Contains(t.Id)).ToList();
                var a = buswork.Where(t => t.BarCode == cutPlanTasks[0].BarCode && t.OprSequenceCode == "Nesting").ToList();
                a.ForEach(t => { t.State = 0; });
                //cutPlanTasks.ForEach(t => { t.CutState = 40; t.UpdateTime = DateTime.Now; t.UpdateBy = userCode; });
                //开启事务，开始执行数据库更新操作
                uw = DALHelper.GetFreeSql().CreateUnitOfWork();
                cutPlanTaskRepository.UnitOfWork = uw;
                buswork.UnitOfWork = uw;
                var result = buswork.Update(a);
                var s = cutPlanTaskRepository.Delete(cutPlanTasks);
                uw?.Commit();
                uw?.Dispose();

                return BllResultFactory.Success($"{result}条切割任务状态更新为【{CutPlanDetailState.切割完成}】成功！");
            }
            catch (Exception ex)
            {
                uw?.Rollback();
                uw?.Dispose();
                return BllResultFactory.Exception(ex, $"状态更新为【{CutPlanDetailState.切割完成}】的时候，发生异常：{ex.Message}");
            }
        }

    }
}