SDLC_WMS/Server/Wms.Core.Infrastructure.Repository/TaskRepository.cs

using AutoMapper;
using Kean.Domain.Task.Models;
using Kean.Domain.Wcs.Models;
using Kean.Infrastructure.Database;
using Kean.Infrastructure.Database.Repository.Default;
using Kean.Infrastructure.Database.Repository.Default.Entities;
using Kean.Infrastructure.Database.Repository.Default.Entities.Interface;
using System;
using System.Collections.Generic;
using System.Security.Cryptography;
using System.Threading.Tasks;

namespace Kean.Infrastructure.Repository
{
    /// <summary>
    /// 任务仓库
    /// </summary>
    public class TaskRepository :
        Domain.Task.Repositories.ITaskRepository
    {
        private readonly IMapper _mapper;
        private readonly IDefaultDb _database;

        /// <summary>
        /// 构造函数
        /// </summary>
        public TaskRepository(
            IMapper mapper,
            IDefaultDb database)
        {
            _mapper = mapper;
            _database = database;
        }

        /*
         * 实现 Kean.Domain.Task.Repositories.ITaskRepository.HasTask 方法
         */
        public async Task<bool> HasTask(int? original, int? destination)
        {
            var schema = _database.From<T_MANAGE_MAIN>();
            if (original.HasValue)
            {
                schema.Where(m => m.START_CELL_ID == original);
            }
            if (destination.HasValue)
            {
                schema.Where(m => m.END_CELL_ID == destination);
            }
            return (await schema.Single(m => new { Count = Function.Count(m.MANAGE_ID) })).Count > 0;
        }

        /*
         * 实现 Kean.Domain.Task.Repositories.ITaskRepository.HasTask 方法
         */
        public async Task<bool> HasTask(string barcode, string originalGroup = null, string destinationGroup = null)
        {
            var schema = _database.From<T_MANAGE_MAIN>().Where(m => m.STOCK_BARCODE == barcode);

            //var queryControl999 = _database.From<IO_CONTROL>().Where(r => r.STOCK_BARCODE == barcode && (r.CONTROL_STATUS == 999 || r.CONTROL_STATUS == 1009)).Query(r => new { r.MANAGE_ID });
            //schema.Where(r => !queryControl999.Contains(r.MANAGE_ID));


            if (originalGroup != null)
            {
                var query = _database.From<T_WH_CELL>().Where(c => c.CELL_GROUP == originalGroup).Query(c => new { c.CELL_ID });
                schema.Where(m => query.Contains(m.START_CELL_ID));
            }
            if (destinationGroup != null)
            {
                var query = _database.From<T_WH_CELL>().Where(c => c.CELL_GROUP == destinationGroup).Query(c => new { c.CELL_ID });
                schema.Where(m => query.Contains(m.END_CELL_ID));
            }
            return (await schema.Single(m => new { Count = Function.Count(m.MANAGE_ID) })).Count > 0;
        }

        /*
         * 实现 Kean.Domain.Task.Repositories.ITaskRepository.GetTask 方法
         */
        public async Task<Domain.Task.Models.Task> GetTask(int id)
        {
            var task = await _database.From<T_MANAGE_MAIN>()
                .Where(m => m.MANAGE_ID == id)
                .Single();
            return task == null ? null : _mapper.Map<Domain.Task.Models.Task>(task);
        }

        /*
         * 实现 Kean.Domain.Task.Repositories.ITaskRepository.GetTask 方法
         */
        public async Task<Domain.Task.Models.Task> GetTask(Domain.Task.Models.Cell cell)
        {
            var task = await _database.From<T_MANAGE_MAIN>()
                .Where(m => m.START_CELL_ID == cell.Id || m.END_CELL_ID == cell.Id)
                .Single();
            return task == null ? null : _mapper.Map<Domain.Task.Models.Task>(task);
        }

        /*
         * 实现 Kean.Domain.Task.Repositories.ITaskRepository.GetFollowed 方法
         */
        public async Task<IEnumerable<Domain.Task.Models.Task>> GetFollows(int id)
        {
            var manageQuery = _database.From<T_MANAGE_MAIN>()
                .Where(m => m.PREVIOUS_ID == id)
                 .Query(r => r.MANAGE_ID);

            var control = await _database.From<IO_CONTROL>()
                .Where(r => manageQuery.Contains(r.MANAGE_ID))
                .Select();

            if (control == null || ((System.Collections.Generic.List<Kean.Infrastructure.Database.Repository.Default.Entities.Interface.IO_CONTROL>)control).Count ==0)
            {
                return _mapper.Map<IEnumerable<Domain.Task.Models.Task>>(await _database.From<T_MANAGE_MAIN>()
    .Where(m => m.PREVIOUS_ID == id)
    .Select());
            }
            else
            {
                return _mapper.Map<IEnumerable<Domain.Task.Models.Task>>(await _database.From<T_MANAGE_MAIN>()
                    .Where(m => m.PREVIOUS_ID == -1)
                    .Select());
            }

        }

        /*
         * 实现 Kean.Domain.Task.Repositories.ITaskRepository.GetCancelFollows 方法
         */
        public async Task<IEnumerable<Domain.Task.Models.Task>> GetCancelFollows(int id)
        {
            return _mapper.Map<IEnumerable<Domain.Task.Models.Task>>(await _database.From<T_MANAGE_MAIN>()
.Where(m => m.PREVIOUS_ID == id && (m.MANAGE_TYPE == "ApplyOut" || m.MANAGE_TYPE == "PalletOut" || m.MANAGE_TYPE == "Outbound"))
.Select());

        }

        /*
         * 实现 Kean.Domain.Task.Repositories.ITaskRepository.CreateTask 方法
         */
        public async Task<int> CreateTask(Domain.Task.Models.Task task)
        {
            var entity = _mapper.Map<T_MANAGE_MAIN>(task);
            entity.MANAGE_STATUS = nameof(Domain.Task.Enums.TaskState.Waiting);
            entity.UPDATE_TIME = entity.CREATE_TIME = DateTime.Now;
            return Convert.ToInt32(await _database.From<T_MANAGE_MAIN>().Add(entity));
        }

        /*
         * 实现 Kean.Domain.Task.Repositories.ITaskRepository.DeleteTask 方法
         */
        public async System.Threading.Tasks.Task DeleteTask(int id)
        {
            await _database.From<T_MANAGE_MAIN>()
                .Where(m => m.MANAGE_ID == id)
                .Delete();
        }

        /*
         * 实现 Kean.Domain.Task.Repositories.ITaskRepository.UpdatePrevious 方法
         */
        public async System.Threading.Tasks.Task UpdatePrevious(int old, int @new)
        {
            await _database.From<T_MANAGE_MAIN>()
                .Where(m => m.PREVIOUS_ID == old)
                .Update(new
                {
                    PREVIOUS_ID = @new,
                    UPDATE_TIME = DateTime.Now
                });
        }

        /*
         * 实现 Kean.Domain.Task.Repositories.ITaskRepository.UpdateStatus 方法
         */
        public async System.Threading.Tasks.Task UpdateStatus(int id, Domain.Task.Enums.TaskState state, string message = null)
        {
            if (!string.IsNullOrEmpty(message) && message.Length > 300)
            {
                message = message.Substring(0, 300);
            }
            await _database.From<T_MANAGE_MAIN>()
                .Where(m => m.MANAGE_ID == id)
                .Update(new
                {
                    MANAGE_STATUS = state.ToString(),
                    MANAGE_REMARK = message,
                    UPDATE_TIME = DateTime.Now
                });
        }

        /*
         * 实现 Kean.Domain.Task.Repositories.ITaskRepository.HasTask 方法
         */
        public async Task<bool> HasTaskByRequestno(string requestno)
        {
            var schema = _database.From<T_MANAGE_MAIN>().Where(m => m.REQUEST_NO == requestno);

            return (await schema.Single(m => new { Count = Function.Count(m.MANAGE_ID) })).Count > 0;
        }

        ///////////////////////////////////////////////////////////////
        /*
         * 实现 Kean.Domain.Task.Repositories.ITaskRepository.GetTaskByBarcode 方法
         */
        public async Task<Domain.Task.Models.Task> GetTaskByBarcode(string barcode)
        {
            var task = await _database.From<T_MANAGE_MAIN>()
                .Where(m => m.STOCK_BARCODE == barcode)
                .Single();
            return task == null ? null : _mapper.Map<Domain.Task.Models.Task>(task);
        }

        /*
         * 实现 Kean.Domain.Task.Repositories.ITaskRepository.UpdateTransitPlace 方法
         */
        public async System.Threading.Tasks.Task UpdateTransitPlace(int id, int transitPlace)
        {
            await _database.From<T_MANAGE_MAIN>()
                .Where(m => m.MANAGE_ID == id)
                .Update(new
                {
                    TRANSIT_CELL_ID = transitPlace,
                    UPDATE_TIME = DateTime.Now
                });
        }

        /*
         * 实现 Kean.Domain.Task.Repositories.ITaskRepository.GetOutAreaFromItem 方法
         */
        public async Task<int> GetOutAreaFromItem(string itemCode,string lineCode)
        {
            int resultArea = 0;

            var item = await _database.From<V_SYS_ITEM_LIST>()
                .Where(r => r.ITEM_CODE == itemCode && r.ITEM_LIST_CODE == lineCode)
                .Single();

            if (item != null)
            {
                try
                {
                    resultArea = Convert.ToInt32(item.ITEM_LIST_REMARK);
                }
                catch { }
            }
            return resultArea;
        }

        /*
         * 实现 Kean.Domain.Task.Repositories.ITaskRepository.GetBypassTag 方法
         */
        public async Task<string> GetBypassTag(string barcode)
        {
            string resultTag = null;

            var stock = await _database.From<T_STORAGE_MAIN>()
                .Where(r => r.STOCK_BARCODE == barcode)
                .Single();

            if (stock != null)
            {
                resultTag = stock.TAG;
            }
            return resultTag;
        }


        /*
        * 实现 Kean.Domain.Task.Repositories.ITaskRepository.HasOutput 方法
        */
        public async Task<bool> HasOutput(int task)
        {
            var schema = _database.From<IO_CONTROL>()
                .Where(r => r.MANAGE_ID == task);
           
            return (await schema.Single(m => new { Count = Function.Count(m.CONTROL_ID) })).Count > 0;
        }

        /*
         * 实现 Kean.Domain.Task.Repositories.ITaskRepository.SetPriority 方法
         */
        public async System.Threading.Tasks.Task SetPriority(int id, int priority)
        {
            await _database.From<T_MANAGE_MAIN>()
                .Where(m => m.MANAGE_ID == id)
                .Update(new
                {
                    PRIORITY = priority,
                    UPDATE_TIME = DateTime.Now
                });
        }

        /*
         * 实现 Kean.Domain.Task.Repositories.ITaskRepository.GetLines 方法
         */
        public async Task<IEnumerable<StockLine>> GetLines(string barcode)
        {
            var query = _database.From<T_STORAGE_MAIN>()
                .Where(s => s.STOCK_BARCODE == barcode)
                .Query(s => s.STORAGE_ID);
            return _mapper.Map<IEnumerable<StockLine>>(await _database.From<T_STORAGE_LIST>()
                .Where(s => query.Contains(s.STORAGE_ID))
                .Select());
        }

        /*
         * 实现 Kean.Domain.Task.Repositories.ITaskRepository.SetErrorStatus 方法
         */
        public async System.Threading.Tasks.Task SetErrorStatus(string barcode, string status, string message)
        {
            var driver = Infrastructure.Database.Configuration.Configure("Default");
            using (var context = driver.CreateContext())
            {
                await context.From<T_MANAGE_MAIN>()
               .Where(m => m.STOCK_BARCODE == barcode)
               .Update(new
               {
                   MANAGE_STATUS = status,
                   MANAGE_REMARK = message,
                   UPDATE_TIME = DateTime.Now
               });
            }
        }

        /*
         * 实现 Kean.Domain.Task.Repositories.ITaskRepository.GetStorageLinesForOrderNo 方法
         */
        public async Task<IEnumerable<StockLine>> GetStorageLinesForOrderNo(string orderNo)
        {
            var queryStockBarcode = _database.From<T_MANAGE_MAIN>()
                .Where(s => s.REQUEST_NO == orderNo)
                .Query(s => s.STOCK_BARCODE);
            var query = _database.From<T_STORAGE_MAIN>()
                .Where(s => queryStockBarcode.Contains(s.STOCK_BARCODE))
                .Query(s => s.STORAGE_ID);
            return _mapper.Map<IEnumerable<StockLine>>(await _database.From<T_STORAGE_LIST>()
                .Where(s => query.Contains(s.STORAGE_ID))
                .Select());
        }

        /*
         * 实现 Kean.Domain.Task.Repositories.ITaskRepository.GetTaskByRequestNo 方法
         */
        public async Task<IEnumerable<Domain.Task.Models.Task>> GetTaskByRequestNo(string requestNo)
        {
            var tasks = await _database.From<T_MANAGE_MAIN>()
              .Where(m => m.REQUEST_NO == requestNo)
              .Select();
            return tasks == null ? null : _mapper.Map< IEnumerable<Domain.Task.Models.Task>>(tasks);
        }


        /*
         * 实现 Kean.Domain.Task.Repositories.ITaskRepository.GetPalletOutManageCount 方法
         */
        public async Task<int> GetPalletOutManageCount(string device)
        {
            var taskCount = await _database.From<T_MANAGE_MAIN>()
              .Where(r => r.END_CELL_ID == int.Parse(device))
              .Single(m => new { Count = Function.Count(m.MANAGE_ID) });
            return taskCount == null ? 0 : taskCount.Count;
        }

        /*
         * 实现 Kean.Domain.Task.Repositories.ITaskRepository.HasMovePalletFromLaXian 方法
         */
        public async Task<bool> HasMovePalletFromLaXian(string device, int goodsId)
        {
            var taskCount = await _database.From<IO_CONTROL, V_STORAGE_LIST>()
              .Join(Join.Inner, (m, c) => m.STOCK_BARCODE == c.STOCK_BARCODE)
              .Where((m, c) => m.END_DEVICE_CODE == device
              && c.GOODS_ID == goodsId)
              .Select((m,c) => new { m.CONTROL_BEGIN_TIME });

            foreach (var m in taskCount)
            {
                if (Convert.ToDateTime(m.CONTROL_BEGIN_TIME) > System.DateTime.Now.AddMinutes(-30))
                {
                    return true;
                }
            }
            //.Single((m, c) => new { Count = Function.Count(m.MANAGE_ID) });
            //return taskCount.Count>0;

            return false;
        }

        /*
         * 实现 Kean.Domain.Task.Repositories.ITaskRepository.GetRepairFollowed 方法
         */
        public async Task<IEnumerable<Domain.Task.Models.Task>> GetRepairFollowed()
        {
            var previousManageQuery = _database.From<T_MANAGE_MAIN>()
                 .Query(r => r.MANAGE_ID);

            var manageQuery = _database.From<T_MANAGE_MAIN>()
                .Where(m => m.PREVIOUS_ID > 0 && !previousManageQuery.Contains(m.PREVIOUS_ID))
                 .Query(r => r.MANAGE_ID);

            var control = await _database.From<IO_CONTROL>()
                .Where(r => manageQuery.Contains(r.MANAGE_ID))
                .Select();

            if (control == null || ((System.Collections.Generic.List<Kean.Infrastructure.Database.Repository.Default.Entities.Interface.IO_CONTROL>)control).Count == 0)
            {
                return _mapper.Map<IEnumerable<Domain.Task.Models.Task>>(await _database.From<T_MANAGE_MAIN>()
    .Where(m => m.PREVIOUS_ID > 0 && !previousManageQuery.Contains(m.PREVIOUS_ID))
    .Select());
            }
            else
            {
                return _mapper.Map<IEnumerable<Domain.Task.Models.Task>>(await _database.From<T_MANAGE_MAIN>()
                    .Where(m => m.PREVIOUS_ID == -1)
                    .Select());
            }

        }

        /*
        * 实现 Kean.Domain.Task.Repositories.ITaskRepository.GetRepairFollowed 方法
        */
        public async System.Threading.Tasks.Task ReSetStockBarcode(string originalStockBarcode, string newStockBarcode)
        {
            await _database.From<T_STORAGE_MAIN>()
               .Where(m => m.STOCK_BARCODE == originalStockBarcode)
               .Update(new
               {
                   STOCK_BARCODE = newStockBarcode,
                   UPDATE_TIME = DateTime.Now
               });
        }

        /*
         * 实现 Kean.Domain.Task.Repositories.ITaskRepository.HasAGVInput 方法
         */
        public async Task<bool> HasAGVInput()
        {
            var schema = _database.From<IO_CONTROL_APPLY>();
            schema.Where(m => m.CONTROL_APPLY_TYPE == "3" && m.APPLY_TASK_STATUS == 3);

            return (await schema.Single(m => new { Count = Function.Count(m.CONTROL_APPLY_ID) })).Count > 0;
        }

        /*
         * 实现 Kean.Domain.Task.Repositories.ITaskRepository.GetStockbarcode 方法
         */
        public async Task<string> GetStockbarcode(int station)
        {
            var stockBarcode = await _database.From<T_STORAGE_MAIN>()
                .Where(r => r.CELL_ID == station)
                .Single();
            return stockBarcode?.STOCK_BARCODE;
        }

        /*
        * 实现 Kean.Domain.Task.Repositories.ITaskRepository.RemoveAGVInput 方法
        */
        public async System.Threading.Tasks.Task RemoveAGVInput()
        {
            var applys = await _database.From<IO_CONTROL_APPLY>().Where(r => r.APPLY_TASK_STATUS == 3 && r.CONTROL_APPLY_TYPE == "3").Select();
            foreach (var apply in applys)
            {
                var entity = _mapper.Map<T_IO_CONTROL>(apply);
                entity.UPDATE_TIME = entity.CREATE_TIME = DateTime.Now;
                await _database.From<T_IO_CONTROL>().Add(entity);

                await _database.From<IO_CONTROL_APPLY>().Where(r => r.CONTROL_APPLY_ID == apply.CONTROL_APPLY_ID).Delete();
            }
        }


        /*
        * 实现 Kean.Domain.Task.Repositories.ITaskRepository.IsPallet 方法
        */
        public async Task<bool> IsPallet(int goodsid)
        {
            return (await _database.From<T_GOODS_MAIN, T_GOODS_CLASS>()
                .Join(Join.Inner, (m, c) => m.CLASS_ID == c.CLASS_ID)
                .Where((m, c) => c.CLASS_FLAG == true && m.GOODS_ID == goodsid && c.CLASS_PARENT_ID == 4)
                .Single((m, c) => new { Count = Function.Count(c.CLASS_ID) })).Count > 0;
        }
    }
}