HKC_Blazor/MasaBlazorApp3/DataAccess/Impl/DrugInfoDao.cs

using LinqToDB;
using log4net;
using MasaBlazorApp3.DataAccess.Dao;
using MasaBlazorApp3.Pojo;
using MasaBlazorApp3.Pojo.Config;
using Microsoft.Extensions.Options;
using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;

namespace MasaBlazorApp3.DataAccess.Impl
{
    public class DrugInfoDao : IDrugInfoDao
    {

        private AppDataConnection _connection;
        private readonly SettingConfig _setting;
        private readonly ILog logger = LogManager.GetLogger(typeof(DrugInfoDao));

        public DrugInfoDao(AppDataConnection connection, IOptions<SettingConfig> setting)
        {
            _connection = connection;
            _setting = setting.Value;
        }
        public async Task<List<DrugInfo>> GetAllDrugAndStock()
        {
            var query = _connection.DrugInfo.AsQueryable();


            return await query
                .LoadWith(di => di.Stocks.Where(cs => cs.Quantity > 0 && cs.MachineId == _setting.machineId))
                .InnerJoin(
                    _connection.ChannelStock.Where(cl => cl.MachineId == _setting.machineId && cl.DrawerType == 1).GroupBy(cl => cl.DrugId),
                    (di, cl) => di.DrugId == cl.Key,
                    (di, cl) => di
                )
                //.Where(cs => cs.Quantity > 0)
                .OrderBy((di) => di.DrugId)
                .ToListAsync();
        }

        public async Task<PageData<DrugInfo>> GetAllDrug(string drugId, string drugName, int? take, int? skip)
        {
            var query = _connection.DrugInfo.AsQueryable();

            if (!String.IsNullOrEmpty(drugId))
            {
                query = query.Where(di => di.DrugId.Contains(drugId));
            }
            if (!String.IsNullOrEmpty(drugName))
            {
                query = query.Where(di => di.DrugName.Contains(drugName));
            }



            int pagedData = await query.CountAsync();
            query = query
                .LoadWith(di => di.Manus)
                .OrderBy((di) => di.DrugId)
                .Skip((int)skip)
                .Take((int)take);

            List<DrugInfo> list = await query
                .ToListAsync();

            return new PageData<DrugInfo>()
            {
                TotalDesserts = pagedData,
                Desserts = list
            };
        }

        public async Task<List<DrugInfo>> GetAllDrug()
        {
            var query = _connection.DrugInfo.AsQueryable();

            return await query
                .LoadWith(di => di.Manus)
                .OrderBy((di) => di.DrugId)
                .ToListAsync();
        }

        public async Task<DrugManuNo> GetDrugManuNo(string drugId, string manuNo)
        {
            var query = _connection.DrugManuNo.AsQueryable();

            return await query.Where(m => m.DrugId.Equals(drugId))
                .Where(m => m.ManuNo.Equals(manuNo))
                .FirstAsync();
        }

        public int AddDrugInfo(DrugInfo drugInfo)
        {
            return _connection.InsertWithInt32Identity(drugInfo);
        }

        public async Task<bool> DeleteDrugInfo(string drugId)
        {
            try
            {
                logger.Error($"删除药品{drugId}");
                return _connection.DrugInfo.Where(di => di.DrugId == drugId).Delete() > 0;
            }
            catch (Exception ex)
            {
                logger.Error("删除药品失败，错误：" + ex.Message);
                return false;
            }
        }

        public async Task<bool> UpdateDrugInfo(DrugInfo drugInfo)
        {
            try
            {
                var statement = _connection.DrugInfo
                    .Where(di => di.DrugId == drugInfo.DrugId)
                    .Set(di => di.DrugName, drugInfo.DrugName)
                    .Set(di => di.DrugSpec, drugInfo.DrugSpec)
                    .Set(di => di.Manufactory, drugInfo.Manufactory);
                return statement.Update() > 0;
            }
            catch (Exception ex)
            {
                logger.Error($"修改药品{drugInfo.DrugId}失败，错误：" + ex.Message);
                return false;
            }
        }
    }
}