BllService.cs 8.27 KB
using HHECS.Application.Service;
using HHECS.BllModel;
using HHECS.Dal;
using HHECS.Dal.Repository;
using HHECS.DAL;
using HHECS.DAL.Repository;
using HHECS.Model.Entities;
using HHECS.Model.Enums;
using System;
using System.Collections.Generic;
using System.Data;
using System.Linq;
using System.Linq.Expressions;
using System.Net.Http;

namespace HHECS.BLL.Services
{
    /// <summary>
    /// 系统相关服务,比如字典查询,设备关系维护等
    /// </summary>
    public class BllService : BaseService
    {
        #region System

        public BllResult<List<Config>> GetAllConfig()
        {
            try
            {
                ConfigRepository configRepository = new ConfigRepository();
                return BllResultFactory.Success(configRepository.Where(t => true).ToList());
            }
            catch (Exception ex)
            {
                return BllResultFactory.Error<List<Config>>($"异常:{ex.Message}");
            }
        }

        public BllResult<Config> GetConfig(string code)
        {
            try
            {
                ConfigRepository configRepository = new ConfigRepository();
                return BllResultFactory.Success(configRepository.Where(t => t.Code == code).First());
            }
            catch (Exception ex)
            {
                return BllResultFactory.Error<Config>($"异常:{ex.Message}");
            }
        }

        public BllResult<Config> GetConfig(int id)
        {
            try
            {
                ConfigRepository configRepository = new ConfigRepository();
                return BllResultFactory.Success(configRepository.Where(t => t.Id == id).First());
            }
            catch (Exception ex)
            {
                return BllResultFactory.Error<Config>($"异常:{ex.Message}");
            }
        }

       

        public BllResult DeleteConfigByIds(List<int> list)
        {
            try
            {
                ConfigRepository configRepository = new ConfigRepository();
                configRepository.Delete(t => list.Contains(t.Id));
                return BllResultFactory.Success();
            }
            catch (Exception ex)
            {
                return BllResultFactory.Error<Config>($"异常:{ex.Message}");
            }
        }

        /// <summary>
        /// 插入或更新字典明细
        /// </summary>
        /// <param name="currentDictDetial"></param>
        /// <returns></returns>
        public BllResult SaveDictDetail(DictDetail currentDictDetial)
        {
            try
            {
                DictDetailRepository dictDetailRepository = new DictDetailRepository();
                dictDetailRepository.InsertOrUpdate(currentDictDetial);
                return BllResultFactory.Success();
            }
            catch (Exception ex)
            {
                return BllResultFactory.Error(ex.Message);
            }
        }

        /// <summary>
        /// 插入或更新字典主表
        /// </summary>
        /// <param name="currentDict"></param>
        /// <returns></returns>
        public BllResult SaveDict(Dict currentDict)
        {
            try
            {
                DictRepository dictRepository = new DictRepository();
                dictRepository.InsertOrUpdate(currentDict);
                return BllResultFactory.Success();
            }
            catch (Exception ex)
            {
                return BllResultFactory.Error(ex.Message);
            }
        }

       

        public BllResult DeleteDictByIds(List<int> list)
        {
            using (var uw = DALHelper.GetFreeSql().CreateUnitOfWork())
            {
                try
                {
                    var dictres = new DictRepository();
                    var dictdetailres = new DictDetailRepository();
                    dictres.UnitOfWork = uw;
                    dictdetailres.UnitOfWork = uw;
                    var dicts = dictres.Where(t => list.Contains(t.Id)).IncludeMany(a => a.DictDetails).ToList();
                    dictres.Delete(dicts);
                    dictdetailres.Delete(dicts.SelectMany(t => t.DictDetails));
                    uw.Commit();
                    return BllResultFactory.Success();
                }
                catch (Exception ex)
                {
                    uw.Rollback();
                    return BllResultFactory.Error(ex.Message);
                }
            }
        }

        /// <summary>
        /// 插入或更新config
        /// </summary>
        /// <param name="config"></param>
        /// <returns></returns>
        public BllResult SaveConfig(Config config)
        {
            try
            {
                ConfigRepository configRepository = new ConfigRepository();
                configRepository.InsertOrUpdate(config);
                return BllResultFactory.Success();
            }
            catch (Exception ex)
            {
                return BllResultFactory.Error(ex.Message);
            }
        }

        public BllResult<Dict> GetDictWithDetails(Expression<Func<Dict, bool>> filter)
        {
            try
            {
                DictRepository dictRepository = new DictRepository();
                var a = dictRepository.Where(filter).IncludeMany(t => t.DictDetails).First();
                if (a == null)
                {
                    return BllResultFactory.Error<Dict>("未查询到数据");
                }
                else
                {
                    return BllResultFactory.Success(a);
                }
            }
            catch (Exception ex)
            {
                return BllResultFactory.Error<Dict>($"异常:{ex.Message}");
            }
        }

        public BllResult<Dict> GetDictWithDetails(Expression<Func<Dict, bool>> filter, Expression<Func<DictDetail, bool>> exp)
        {
            try
            {
                DictRepository dictRepository = new DictRepository();
                var a = dictRepository.Where(filter).IncludeMany(t => t.DictDetails, then => then.Where(exp)).First();
                if (a == null)
                {
                    return BllResultFactory.Error<Dict>("未查询到数据");
                }
                else
                {
                    return BllResultFactory.Success(a);
                }
            }
            catch (Exception ex)
            {
                return BllResultFactory.Error<Dict>($"异常:{ex.Message}");
            }
        }


        public BllResult DeleteDictDetailByIds(List<int> lists)
        {
            try
            {
                DictDetailRepository dictDetailRepository = new DictDetailRepository();
                dictDetailRepository.Delete(t => lists.Contains(t.Id));
                return BllResultFactory.Success();
            }
            catch (Exception ex)
            {
                return BllResultFactory.Error(ex.Message);
            }
        }


        public BllResult InsertCollectionLog(string printRecive)
        {
            var results = printRecive.Split("/n".ToCharArray(), StringSplitOptions.RemoveEmptyEntries);
            BusCollectionResultRepository busCollectionLogRepository = new BusCollectionResultRepository();
            List<BusCollectionResult> collectionLogs = new List<BusCollectionResult>();
            foreach (var result in results)
            {
                var busCollectionLog = new BusCollectionResult();
                busCollectionLog.Keys = Guid.NewGuid();
                busCollectionLog.Value = result;
                busCollectionLog.ExternalEquipmentCode = "";
                busCollectionLog.CreateTime = DateTime.Now;
                busCollectionLog.CreateBy = "";
                collectionLogs.Add(busCollectionLog);
            }
            using (var uw = DALHelper.GetFreeSql().CreateUnitOfWork())
            {
                try
                {
                    busCollectionLogRepository.UnitOfWork = uw;
                    busCollectionLogRepository.Insert(collectionLogs);
                    uw.Commit();
                    return BllResultFactory.Success();

                }
                catch (Exception ex)
                {
                    uw?.Rollback();
                    return BllResultFactory.Error(ex.Message);

                }
            }
        }

        #endregion

    }
}