~jt/AutoWMS.lanyueliang.git

using System;
using System.Collections.Generic;
using System.Linq;
using HH.WMS.Entitys.Algorithm;
using System.Text;
using System.Threading.Tasks;
using HH.MData;
using MongoDB.Driver;
using MongoDB.Bson;
using System.Text.RegularExpressions;
using MongoDB.Driver.Builders;
using HH.WMS.Common;
using System.Data;
using System.Data.Common;
using MongoDB.Driver.Builders;
using MongoDB.Driver;
using HH.WMS.Entitys.Basic;
using HH.WMS.DAL.Basic;
 
 
namespace HH.WMS.DAL.Algorithm
{
    /// <summary>
    /// 用户读取mongodb中的逻辑分区和库区
    /// </summary>
    public class TN_WMS_AREADAL : BaseDAL
    {
        #region 获得当前物料所在逻辑分区关联仓库/库区/货位信息
        /// <summary>
        /// 获得当前物料所在逻辑分区关联仓库/库区/货位信息
        /// </summary>
        /// <param name="filedValue"></param>
        /// <param name="logicType">1:存储类别  2：物料编码</param>
        /// <returns></returns>
        public List<AutoBomPartition_Item_REntity> GetPartitionItem(string filedValue, int logicType)
        {
            //定义查询条件
            var query = new QueryDocument();
            var b = new BsonDocument();
            //物料分类
            switch (logicType)
            {
                case 1://存储类别
                    b.Add("CN_N_LOGIC_TYPE", 1);
                    b.Add("CN_S_NAME", new Regex(filedValue.ToString(), RegexOptions.IgnoreCase));
                    break;
                case 2://物料编码
                    b.Add("CN_N_LOGIC_TYPE", 2);
                    b.Add("CN_S_NAME", new Regex(filedValue.ToString(), RegexOptions.IgnoreCase));
                    break;
            }
            query.Add(b);
 
            //定义排序 按照优先级正序排列
            SortByDocument sort = new SortByDocument { { "CN_S_PRIORITY", 1 } };
 
            //根据查询条件获得所有逻辑分区物料关联信息
            List<AutoBomPartition_Item_REntity> listLogic_item = MongoDBSingleton.Instance.Find<AutoBomPartition_Item_REntity>(query, sort, "TN_AB_B_PARTITION_ITEM_R");
 
            return listLogic_item;
        }
        #endregion
 
        #region 根据逻辑分区编码和库区编码获得关联关系
        /// <summary>
        /// 根据逻辑分区编码获得所在仓库/库区/货位
        /// </summary>
        /// <param name="logicCodes">逻辑分区编码</param>
        /// <param name="areaCode">库区编码</param>
        /// <returns></returns>
        /// <History>[Hanhe(DBS)] created 2018-5-9</History>
        public List<AutoBomAreaLocation_REntity> GetLogicListByLogicAndArea(List<string> logicCodes, string areaCode)
        {
            List<AutoBomAreaLocation_REntity> listLogic = new List<AutoBomAreaLocation_REntity>();
 
            var locations = logicCodes.ConvertAll<BsonValue>(x => x);
 
            IMongoQuery query;
 
            if (!string.IsNullOrEmpty(areaCode))
            {
                query = Query.And(Query.In("CN_S_AREA_CODE", locations), Query.EQ("CN_S_STOCK_AREA", areaCode));
            }
            else
            {
                //查询条件
                query = Query.In("CN_S_AREA_CODE", locations);
            }
 
            //定义排序  按优先级正序排列
            SortByDocument sort = new SortByDocument { { "CN_S_PRIORITY", 1 } };
 
            listLogic = MongoDBSingleton.Instance.Find<AutoBomAreaLocation_REntity>(query, sort, "TN_AB_B_AREA_LOCATION_R");
            return listLogic;
        }
        #endregion
 
        #region 根据逻辑分区编码和库区编码获得货位
        /// <summary>
        /// 根据逻辑分区编码获得所在仓库/库区/货位
        /// </summary>
        /// <param name="logicCodes">逻辑分区编码</param>
        /// <param name="areaCode">库区编码</param>
        /// <returns></returns>
        /// <History>[Hanhe(DBS)] created 2018-5-9</History>
        public List<AutoBomAreaLocation_REntity> GetLogicListByLogicAndArea(string logicCodes, string areaCode)
        {
            List<AutoBomAreaLocation_REntity> listLogic = new List<AutoBomAreaLocation_REntity>();
            IMongoQuery query;
            query = Query.And(Query.EQ("CN_S_AREA_CODE", logicCodes), Query.EQ("CN_S_STOCK_AREA", areaCode));
 
            //定义排序  按优先级正序排列
            SortByDocument sort = new SortByDocument { { "CN_S_PRIORITY", 1 } };
 
            listLogic = MongoDBSingleton.Instance.Find<AutoBomAreaLocation_REntity>(query, sort, "TN_AB_B_AREA_LOCATION_R");
            return listLogic;
        }
        #endregion
 
        #region 返回指定逻辑分区、库区下的所有货位
        /// <summary>
        /// 返回指定逻辑分区、库区下的所有货位
        /// </summary>
        /// <param name="logicCodes">逻辑分区</param>
        /// <param name="areaCode">库区</param>
        /// <returns></returns>
        /// <History>[Hanhe(DBS)] created 2018-5-9</History>
        public List<LogicAreaLocationEntity> GetLocation(List<string> logicCodes, string areaCode)
        {
            List<AutoBomAreaLocation_REntity> listLogic = new List<AutoBomAreaLocation_REntity>();
            var arrLogic = logicCodes.ConvertAll<BsonValue>(x => x);
 
            IMongoQuery query;
            if (!string.IsNullOrEmpty(areaCode))
            {
                query = Query.And(Query.In("CN_S_AREA_CODE", arrLogic), Query.EQ("CN_S_STOCK_AREA", areaCode));
            }
            else
            {
                //查询条件
                query = Query.In("CN_S_AREA_CODE", arrLogic);
            }
 
            //定义排序  按优先级正序排列
            SortByDocument sort = new SortByDocument { { "CN_S_PRIORITY", 1 } };
 
            listLogic = MongoDBSingleton.Instance.Find<AutoBomAreaLocation_REntity>(query, sort, "TN_AB_B_AREA_LOCATION_R");
            if (listLogic == null)
            {
                //未找到合适逻辑分区下的货位
                return new List<LogicAreaLocationEntity>();
            }
            var arrLocation = listLogic.ConvertAll<BsonValue>(x => x.CN_S_LOCATION_CODE);
            if (!string.IsNullOrEmpty(areaCode))
                query = Query.And(Query.In("CN_S_LOCATION_CODE", arrLocation), Query.EQ("CN_S_AREA_CODE", areaCode));
            else
                query = Query.And(Query.In("CN_S_LOCATION_CODE", arrLocation));
            sort = new SortByDocument { { "CN_S_ROW", 1 }, { "CN_S_COL", 1 }, { "CN_S_FLOOR", 1 } };
 
            List<AutoBomLocationEntity> locationList = MongoDBSingleton.Instance.Find<AutoBomLocationEntity>(query, sort, "TN_AB_STOCK_LOCATION");
 
            List<LogicAreaLocationEntity> logicAreaLocation = new List<LogicAreaLocationEntity>();
 
            foreach (AutoBomAreaLocation_REntity x in listLogic)
            {
                var v = locationList.Find(y => y.CN_S_LOCATION_CODE.Equals(x.CN_S_LOCATION_CODE));
                if (v != null)
                {
                    logicAreaLocation.Add(new LogicAreaLocationEntity
                    {
                        CN_S_LOCATION_CODE = x.CN_S_LOCATION_CODE,
                        CN_S_AREA_CODE = x.CN_S_AREA_CODE,
                        CN_S_STOCK_CODE = x.CN_S_STOCK_CODE,
                        CN_S_ROW = v.CN_S_ROW,
                        CN_S_COL = v.CN_S_COL,
                        CN_S_FLOOR = v.CN_S_FLOOR,
                        CN_S_STOCK_AREA = x.CN_S_STOCK_AREA
                    });
                }
            }
 
            return logicAreaLocation;
        }
        #endregion
 
        #region 根据货位查询库位和逻辑分区的关联
        /// <summary>
        /// 根据货位查询库位和逻辑分区的关联
        /// </summary>
        /// <param name="locations"></param>
        /// <returns></returns>
        public List<AutoBomAreaLocation_REntity> GetLogicAreaLocation(List<string> list)
        {
            //定义排序  按优先级正序排列
            SortByDocument sort = new SortByDocument { { "CN_S_PRIORITY", 1 } };
            var locations = list.ConvertAll<BsonValue>(x => x);
            var query = Query.And(Query.In("CN_S_LOCATION_CODE", locations));
            return MongoDBSingleton.Instance.Find<AutoBomAreaLocation_REntity>(query, sort, "TN_AB_B_AREA_LOCATION_R");
        }
 
        #endregion
 
        #region 根据库区获得所在仓库/库区/货位
        /// <summary>
        /// 根据库区获得所在仓库/库区/货位
        /// </summary>
        /// <param name="areaCode">库区编码</param>
        /// <returns></returns>
        public List<AutoBomAreaLocation_REntity> GetLogicListByAreaCode(string areaCode)
        {
            List<AutoBomAreaLocation_REntity> listLogic = new List<AutoBomAreaLocation_REntity>();
 
            //定义排序  按优先级正序排列
            SortByDocument sort = new SortByDocument { { "CN_S_PRIORITY", 1 } };
 
            //条件  库区
            var query = Query.EQ("CN_S_STOCK_AREA", areaCode);
            //根据库区编码到逻辑分区仓库/库区/货位关联中查找数据
            listLogic = MongoDBSingleton.Instance.Find<AutoBomAreaLocation_REntity>(query, sort, "TN_AB_B_AREA_LOCATION_R");
 
            //如果根据库区没有取到逻辑分区  则根据库区所在仓库取逻辑分区
            if (listLogic == null || listLogic.Count == 0)
            {
                //根据库区取仓库
                string stockCode = GetStockCodeByAreaCode(areaCode);
                if (!string.IsNullOrEmpty(stockCode))
                {
                    query = Query.EQ("CN_S_STOCK_CODE", stockCode);
                    listLogic = MongoDBSingleton.Instance.Find<AutoBomAreaLocation_REntity>(query, sort, "TN_AB_B_AREA_LOCATION_R");
                }
            }
 
            //如果根据库区和仓库都没有取到逻辑分区  则根据库区下的货位取逻辑分区
            if (listLogic == null || listLogic.Count == 0)
            {
                TN_WMS_LOCATIONDAL lcoationDal = new TN_WMS_LOCATIONDAL();
                List<AutoBomLocationAbbreEntity> lstLocation = lcoationDal.GetLocationByAreaCode(areaCode);
                if (lstLocation != null && lstLocation.Count > 0)
                {
                    var locations = lstLocation.ConvertAll<BsonValue>(x => x.CN_S_LOCATION_CODE);
                    query = Query.In("CN_S_LOCATION_CODE", locations);
                    listLogic = MongoDBSingleton.Instance.Find<AutoBomAreaLocation_REntity>(query, sort, "TN_AB_B_AREA_LOCATION_R");
                }
            }
            return listLogic;
        }
        public List<AutoBomAreaLocation_REntity> GetLogicListByLogicCode(List<string> lstLog, string CN_N_TYPE)
        {
            List<AutoBomAreaLocation_REntity> listLogic = new List<AutoBomAreaLocation_REntity>();
 
            //定义排序  按优先级正序排列
            SortByDocument sort = new SortByDocument { { "CN_S_PRIORITY", 1 } };
            TN_WMS_LOCATIONDAL lcoationDal = new TN_WMS_LOCATIONDAL();
            var logicCodes = lstLog.ConvertAll<BsonValue>(x => x);
            var query = Query.And(Query.In("CN_S_STOCK_AREA", logicCodes), Query.EQ("CN_N_TYPE", int.Parse(CN_N_TYPE)));
            // var query = Query.And(Query.In("CN_S_STOCK_AREA", logicCodes));
            listLogic = MongoDBSingleton.Instance.Find<AutoBomAreaLocation_REntity>(query, sort, "TN_AB_B_AREA_LOCATION_R");
            return listLogic;
 
        }
        public List<AutoBomAreaLocation_REntity> GetLogicListByLogicCode(string logicCode)
        {
            List<AutoBomAreaLocation_REntity> listLogic = new List<AutoBomAreaLocation_REntity>();
 
            //定义排序  按优先级正序排列
            SortByDocument sort = new SortByDocument { { "CN_S_PRIORITY", 1 } };
            TN_WMS_LOCATIONDAL lcoationDal = new TN_WMS_LOCATIONDAL();
            var query = Query.EQ("CN_S_AREA_CODE", logicCode);
            listLogic = MongoDBSingleton.Instance.Find<AutoBomAreaLocation_REntity>(query, sort, "TN_AB_B_AREA_LOCATION_R");
            return listLogic;
 
        }
        /// <summary>
        /// 根据库区和物料查询安全库存
        /// </summary>
        /// <param name="lstArea"></param>
        /// <param name="itemCode"></param>
        /// <returns></returns>
        public List<TN_AB_B_ITEM_SAFETYEntity> GetItemAreaSafetyByAreaCode(List<string> lstArea, string itemCode)
        {
            List<TN_AB_B_ITEM_SAFETYEntity> listSafety = new List<TN_AB_B_ITEM_SAFETYEntity>();
            TN_WMS_LOCATIONDAL lcoationDal = new TN_WMS_LOCATIONDAL();
            SortByDocument sort = new SortByDocument { { "CN_S_AREA_CODE", 1 } };
            var areaCodeS = lstArea.ConvertAll<BsonValue>(x => x);
            IMongoQuery query;
            query = Query.And(Query.EQ("CN_S_ITEM_CODE", itemCode), Query.In("CN_S_AREA_CODE", areaCodeS));
            listSafety = MongoDBSingleton.Instance.Find<TN_AB_B_ITEM_SAFETYEntity>(query, sort, "TN_AB_B_ITEM_SAFETY");
            return listSafety;
        }
 
        #endregion
 
        #region 根据库区编码获得仓库编号
        /// <summary>
        /// 根据库区编码获得仓库编号
        /// </summary>
        /// <param name="areaCode"></param>
        /// <returns></returns>
        public string GetStockCodeByAreaCode(string areaCode)
        {
            string stockCode = string.Empty;
            var query = Query.EQ("CN_S_AREA_CODE", areaCode);
            AutoBomStockAreaEntity entity = MongoDBSingleton.Instance.FindOne<AutoBomStockAreaEntity>(query, "TN_AB_B_STOCK_AREA");
            if (entity != null)
            {
                stockCode = entity.CN_S_STOCK_CODE;
            }
            return stockCode;
        }
        #endregion
 
        #region 根据库区编码获得库区类型（立库/平库/流离式）
        /// <summary>
        /// 根据库区编码获得仓库编号
        /// </summary>
        /// <param name="areaCode"></param>
        /// <returns></returns>
        public string GetAreaTypeByCode(string areaCode)
        {
            string areaType = string.Empty;
            var query = Query.EQ("CN_S_AREA_CODE", areaCode);
            AutoBomStockAreaEntity entity = MongoDBSingleton.Instance.FindOne<AutoBomStockAreaEntity>(query, "TN_AB_B_STOCK_AREA");
            if (entity != null)
            {
                areaType = entity.CN_S_STRUCTURE;
            }
            return areaType;
        }
        #endregion
        #region 根据库区编码获得库区类型（立库/平库/流离式）
        /// <summary>
        /// 根据库区编码获得是否为作业区
        /// </summary>
        /// <param name="areaCode"></param>
        /// <returns></returns>
        public string GetCNNTypeByCode(string areaCode)
        {
            string areaType = string.Empty;
            var query = Query.EQ("CN_S_AREA_CODE", areaCode);
            AutoBomStockAreaEntity entity = MongoDBSingleton.Instance.FindOne<AutoBomStockAreaEntity>(query, "TN_AB_B_STOCK_AREA");
            if (entity != null)
            {
                areaType = entity.CN_N_TYPE.ToString();
            }
            return areaType;
        }
        /// <summary>
        /// 根据库区编码获得是否为作业区（批量）
        /// </summary>
        /// <param name="areaCode"></param>
        /// <returns></returns>
        public List<string> SortAreaByCNNType(List<string> lstArea)
        {
            string areaType = string.Empty;
            List<AutoBomStockAreaEntity> lstResult = new List<AutoBomStockAreaEntity>();
            var AreaCodes = lstArea.ConvertAll<BsonValue>(x => x);
            var query = Query.In("CN_S_AREA_CODE", AreaCodes);
            //定义排序  按优先级正序排列
            SortByDocument sort = new SortByDocument { { "CN_N_TYPE", 1 } };
            lstResult = MongoDBSingleton.Instance.Find<AutoBomStockAreaEntity>(query, sort, "TN_AB_B_STOCK_AREA");
            return lstResult.Select(o => o.CN_S_AREA_CODE).ToList();
        }
        #endregion
        #region 根据库区编码获得库区类型（立库/平库/流离式）
        /// <summary>
        /// 根据库区编码获得是否为作业区
        /// </summary>
        /// <param name="areaCode"></param>
        /// <returns></returns>
        public string GetAreaClassByCode(string areaCode)
        {
            string areaClass = string.Empty;
            var query = Query.EQ("CN_S_AREA_CODE", areaCode);
            AutoBomStockAreaEntity entity = MongoDBSingleton.Instance.FindOne<AutoBomStockAreaEntity>(query, "TN_AB_B_STOCK_AREA");
            if (entity != null)
            {
                areaClass = entity.CN_S_AREA_CLASS.ToString();
            }
            return areaClass;
        }
        public List<AutoBomStockAreaEntity> GetAreaCodeByClass(string areaClass)
        {
            string areaCode = string.Empty;
            var query = Query.EQ("CN_S_AREA_CLASS", areaClass);
            List<AutoBomStockAreaEntity> lstArea = MongoDBSingleton.Instance.Find<AutoBomStockAreaEntity>(query, "TN_AB_B_STOCK_AREA");
            return lstArea;
        }
 
        #endregion
        #region 根据库区编码获得是否管控数量（立库/平库/流离式）
        /// <summary>
        /// 根据库区编码获得是否管控数量
        /// </summary>
        /// <param name="areaCode"></param>
        /// <returns></returns>
        public string GetIsControlQtyByCode(string areaCode)
        {
            string areaType = string.Empty;
            try
            {
 
                var query = Query.EQ("CN_S_AREA_CODE", areaCode);
                AutoBomStockAreaEntity entity = MongoDBSingleton.Instance.FindOne<AutoBomStockAreaEntity>(query, "TN_AB_B_STOCK_AREA");
                if (entity != null)
                {
                    areaType = entity.CN_C_IS_CONTROL_QTY;
                }
 
 
            }
            catch (Exception ex)
            {
                Log.AlgorInfo("In—InAssign", "GetIsControlQtyByCode：" + ex.Message + ex.StackTrace);
            }
            return areaType;
        }
        #endregion
 
        #region 根据逻辑分区编码和库区编码获得货位
        /// <summary>
        /// 根据逻辑分区编码获得所在仓库/库区/货位
        /// </summary>
        /// <param name="logicCodes">逻辑分区编码</param>
        /// <param name="areaCode">库区编码</param>
        /// <returns></returns>
        /// <History>[Hanhe(DBS)] created 2018-5-9</History>
        public List<AutoBomAreaLocation_REntity> GetLocationByLogicArea(string logicCodes, string areaCode)
        {
            List<AutoBomAreaLocation_REntity> listLogic = new List<AutoBomAreaLocation_REntity>();
            IMongoQuery query;
            query = Query.And(Query.EQ("CN_S_AREA_CODE", logicCodes), Query.EQ("CN_S_STOCK_AREA", areaCode));
 
            //定义排序  按优先级正序排列
            SortByDocument sort = new SortByDocument { { "CN_S_PRIORITY", 1 } };
 
            listLogic = MongoDBSingleton.Instance.Find<AutoBomAreaLocation_REntity>(query, sort, "TN_AB_B_AREA_LOCATION_R");
            return listLogic;
        }
        public List<AutoBomAreaLocation_REntity> GetLocationByLogicAreaJX(string logicCodes, string areaCode)
        {
            List<AutoBomAreaLocation_REntity> listLogic = new List<AutoBomAreaLocation_REntity>();
            IMongoQuery query;
            query = Query.EQ("CN_S_STOCK_AREA", areaCode);
 
            //定义排序  按优先级正序排列
            SortByDocument sort = new SortByDocument { { "CN_S_PRIORITY", 1 } };
 
            listLogic = MongoDBSingleton.Instance.Find<AutoBomAreaLocation_REntity>(query, sort, "TN_AB_B_AREA_LOCATION_R");
            return listLogic;
        }
        #endregion
        #region 根据库区编码获得货位
        /// <summary>
        /// 根据逻辑分区编码获得所在仓库/库区/货位
        /// </summary>
        /// <param name="logicCodes">逻辑分区编码</param>
        /// <param name="areaCode">库区编码</param>
        /// <returns></returns>
        /// <History>[Hanhe(DBS)] created 2018-5-9</History>
        public List<AutoBomAreaLocation_REntity> GetLogicLocationByArea(string areaCode)
        {
            List<AutoBomAreaLocation_REntity> listLogic = new List<AutoBomAreaLocation_REntity>();
            IMongoQuery query;
            query = Query.EQ("CN_S_STOCK_AREA", areaCode);
            //定义排序  按优先级正序排列
            SortByDocument sort = new SortByDocument { { "CN_S_PRIORITY", 1 } };
            listLogic = MongoDBSingleton.Instance.Find<AutoBomAreaLocation_REntity>(query, sort, "TN_AB_B_AREA_LOCATION_R");
            return listLogic;
        }
        #endregion
        #region 根据库区编码货物库区实体
        /// <summary>
        /// 根据库区编码货物库区实体
        /// </summary>
        /// <param name="areaCode"></param>
        /// <returns></returns>
        public AutoBomStockAreaEntity GetModel(string areaCode)
        {
            var query = Query.EQ("CN_S_AREA_CODE", areaCode);
            AutoBomStockAreaEntity entity = MongoDBSingleton.Instance.FindOne<AutoBomStockAreaEntity>(query, "TN_AB_B_STOCK_AREA");
            return entity;
        }
 
        /// <summary>
        /// 根据库区编码货物库区实体
        /// </summary>
        /// <param name="areaCode"></param>
        /// <returns></returns>
        public List<AutoBomStockAreaEntity> GetStockAreaList(List<string> areaCodelist)
        {
            List<AutoBomStockAreaEntity> entityList = new List<AutoBomStockAreaEntity>();
            var areaCode = areaCodelist.ConvertAll<BsonValue>(x => x);
            var query = Query.In("CN_S_AREA_CODE", areaCode);
            entityList = MongoDBSingleton.Instance.Find<AutoBomStockAreaEntity>(query, "TN_AB_B_STOCK_AREA");
            return entityList;
        }
        #endregion
 
        #region 根据分区唯一码获取信息
        /// <summary>
        ///根据分区唯一码获取信息
        /// </summary>
        /// <param name="CN_S_AREA_GUID">分区唯一码</param>
        /// <returns></returns>
        /// <history>[HanHe(LT)] CREATED 2018/6/21</history>
        public List<AutoBomAreaLocation_REntity> GetAreaLocationByGuid(string CN_S_AREA_GUID)
        {
            IMongoQuery query = Query.EQ("CN_S_AREA_GUID", CN_S_AREA_GUID);
            List<AutoBomAreaLocation_REntity> entity = MongoDBSingleton.Instance.Find<AutoBomAreaLocation_REntity>(query, "TN_AB_B_AREA_LOCATION_R");
            return entity;
        }
        #endregion
        public List<AutoBomStockAreaEntity> GetSHLocationArea(string areaClass)
        {
            List<AutoBomStockAreaEntity> listLogic = new List<AutoBomStockAreaEntity>();
            var query = Query.EQ("CN_S_AREA_CLASS", areaClass);
            listLogic = MongoDBSingleton.Instance.Find<AutoBomStockAreaEntity>(query, "TN_AB_B_STOCK_AREA");
 
            return listLogic;
        }
 
        public List<AutoBomLocationEntity> GetSHLocation(List<string> arrAreaCode)
        {
            List<AutoBomLocationEntity> locationList = new List<AutoBomLocationEntity>();
            var arrLogic = arrAreaCode.ConvertAll<BsonValue>(x => x);
            var query = Query.In("CN_S_AREA_CODE", arrLogic);
            locationList = MongoDBSingleton.Instance.Find<AutoBomLocationEntity>(query, "TN_AB_STOCK_LOCATION");
            return locationList;
        }
 
        public List<AutoBomPartition_Item_REntity> GetitemListByLocation(string locationCode)
        {
            IMongoQuery query;
            List<AutoBomPartition_Item_REntity> listLogic_item = new List<AutoBomPartition_Item_REntity>();
 
            if (!string.IsNullOrEmpty(locationCode))
            {
                List<AutoBomItemEntity> itemList = new List<AutoBomItemEntity>();
 
                query = Query.And(Query.EQ("CN_S_LOCATION_CODE", locationCode));
                //定义排序  按优先级正序排列
                SortByDocument sort = new SortByDocument { { "CN_S_PRIORITY", 1 } };
 
                List<AutoBomAreaLocation_REntity> listLogic = new List<AutoBomAreaLocation_REntity>();
 
                listLogic = MongoDBSingleton.Instance.Find<AutoBomAreaLocation_REntity>(query, sort, "TN_AB_B_AREA_LOCATION_R");
                if (listLogic != null)
                {
                    foreach (AutoBomAreaLocation_REntity x in listLogic)
                    {
 
                        IMongoQuery queryPir;
 
                        queryPir = Query.EQ("CN_S_AREA_CODE", x.CN_S_AREA_CODE);
 
                        List<AutoBomPartition_Item_REntity> item = MongoDBSingleton.Instance.Find<AutoBomPartition_Item_REntity>(queryPir, sort, "TN_AB_B_PARTITION_ITEM_R");
                        if (item.Any())
                        {
                            listLogic_item.AddRange(item);
                        }
                    }
                }
            }
            return listLogic_item;
 
        }
    }
}